home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware Overload Trio 2
/
Shareware Overload Trio Volume 2 (Chestnut CD-ROM).ISO
/
dir34
/
2m21src.zip
/
2M-XBIOS.ASM
< prev
next >
Wrap
Assembly Source File
|
1994-05-31
|
125KB
|
3,052 lines
;*********************************************************************
;* *
;* 2M-XBIOS 1.2 - (C) Mayo 1994 Ciriaco García de Celis. *
;* *
;* Código para emular al 100% la BIOS AMI de 1993. *
;* En máquinas PC/XT *
;* *
;* Si el ordenador posee disco duro y una BIOS moderna, la *
;* INT 40h controla los accesos a disquete. Desviar esta *
;* interrupción en lugar de la INT 13h permite que este *
;* programa tome el control de las disqueteras antes que *
;* cualquier otro (incluso aunque se instale después) y *
;* además permite seguir trabajando al código del DOS que, *
;* desde INT 13h, soluciona el cruce con las fronteras de *
;* DMA antes de invocar a la INT 40h. *
;* *
;* Si el ordenador no utilizase la INT 40h en los accesos a *
;* las disqueteras se desvía INT 13h y se cuelga este código *
;* de la misma, cuidando evitar un cruce con el DMA a través *
;* de un buffer intermedio auxiliar si es preciso. *
;* *
;* Ensamblar con TASM /m5 y linkar con TLINK para obtener un *
;* fichero EXE que se instala con DEVICE desde el CONFIG.SYS *
;* *
;*********************************************************************
; ------------ Macros de propósito general.
XPUSH MACRO regmem ; apilar lista de registros
IRP rm, <regmem>
PUSH rm
ENDM
ENDM
XPOP MACRO regmem ; desapilar lista de registros
IRP rm, <regmem>
POP rm
ENDM
ENDM
XPUSHA MACRO
XPUSH <AX, BX, CX, DX, SI, DI>
ENDM
XPOPA MACRO
XPOP <DI, SI, DX, CX, BX, AX>
ENDM
XSHL MACRO regmem, cuenta
REPT cuenta
SHL regmem,1
ENDM
ENDM
XSHR MACRO regmem, cuenta
REPT cuenta
SHR regmem,1
ENDM
ENDM
XROR MACRO regmem, cuenta
REPT cuenta
ROR regmem,1
ENDM
ENDM
XROL MACRO regmem, cuenta
REPT cuenta
ROL regmem,1
ENDM
ENDM
; ************ Inicio del área residente.
_PRINCIPAL SEGMENT
ASSUME CS:_PRINCIPAL, DS:_PRINCIPAL
ORG 0
ini_residente EQU $
DD -1 ; encadenamiento con otros drivers
tipo_drive DW 8000h ; palabra de atributo:
; bit 15 a 1: dispositivo caracteres
; bit 14 a 0: sin control IOCTL
DW estrategia ; rutina de estrategia
DW interrupcion ; rutina de interrupción
DB "2M-BIOS$" ; nombre del dispositivo
estrategia PROC FAR
MOV CS:pcab_pet_segm,ES
MOV CS:pcab_pet_desp,BX
RET
estrategia ENDP
interrupcion PROC FAR
CALL main ; tras instalar: XPUSH <DS, BX> y MOV BX,??
pcab_pet_segm DW ?
MOV DS,BX
DB 0BBh ; opcode de MOV BX,??
pcab_pet_desp DW ?
MOV WORD PTR [BX+3],8103h ; código de error
XPOP <BX, DS>
RET
interrupcion ENDP
; ****************************************
; * *
; * D A T O S R E S I D E N T E S *
; * *
; ****************************************
; ------------ Identificación estandarizada del programa.
program_id LABEL BYTE
segmento_real DW 0 ; segmento real donde será cargado
offset_real DW 0 ; offset real " " "
longitud_total DW 0 ; zona de memoria ocupada (párrafos)
info_extra DB 03h ; bits 0, 1 y 2-> 000: normal, con PSP
; 001: bloque UMB XMS
; 010: *.SYS
; 011: *.SYS formato EXE
; bit 7 a 1: «extension_id» definida
multiplex_id DB 0 ; número Multiplex de este TSR
vectores_id DW tabla_vectores
extension_id DW 0
DB "*##*"
autor_nom_ver DB "CiriSOFT:2M-XBIOS:1.2",0
DB 3 ; número de vectores de interrupción usados
tabla_vectores EQU $
DB 15h ; INT 15h
ant_int15 LABEL DWORD ; dirección original
ant_int15_off DW 0
ant_int15_seg DW 0
DB 2Fh ; INT 2Fh
ant_int2F LABEL DWORD ; dirección original
ant_int2F_off DW 0
ant_int2F_seg DW 0
DB 40h ; INT 40h
ant_int40 LABEL DWORD ; dirección original
ant_int40_off DW 0
ant_int40_seg DW 0
DB 13h ; INT 13h podría llegar a usarse
ant_int13 LABEL DWORD
ant_int13_off DW 0
ant_int13_seg DW 0
; ***************************************
; * *
; * C O D I G O R E S I D E N T E *
; * *
; ***************************************
; ------------ Rutina de gestión de INT 2Fh.
ges_int2F PROC FAR
STI
CMP AH,CS:multiplex_id
JE preguntan
JMP CS:ant_int2F ; saltar al gestor de INT 2Fh
preguntan: CMP DI,1992h
JNE ret_no_info ; no llama alguien del convenio
MOV AX,ES
CMP AX,1492h
JNE ret_no_info ; no llama alguien del convenio
PUSH CS
POP ES ; sí llama: darle información
LEA DI,autor_nom_ver
ret_no_info: MOV AX,0FFFFh ; "entrada multiplex en uso"
IRET
ges_int2F ENDP
; ------------ Rutina de gestión de INT 15h.
ges_int15 PROC FAR
STI
CMP AX,90FDh
JE ret_clc
CMP AX,9001h
JE ret_clc
JMP CS:ant_int15
ret_clc: CLC
RET 2
ges_int15 ENDP
; ------------ Rutina de control de INT 40h.
r_flags EQU WORD PTR [BP+18h] ; constantes para parámetros
r_flags_l EQU BYTE PTR [BP+18h]
r_flags_h EQU BYTE PTR [BP+19h]
r_ax EQU WORD PTR [BP+12h]
r_al EQU BYTE PTR [BP+12h]
r_ah EQU BYTE PTR [BP+13h]
r_cx EQU WORD PTR [BP+10h]
r_cl EQU BYTE PTR [BP+10h]
r_ch EQU BYTE PTR [BP+11h]
r_dx EQU WORD PTR [BP+0Eh]
r_dl EQU BYTE PTR [BP+0Eh]
r_dh EQU BYTE PTR [BP+0Fh]
r_bx EQU WORD PTR [BP+0Ch]
r_bl EQU BYTE PTR [BP+0Ch]
r_bh EQU BYTE PTR [BP+0Dh]
r_bp EQU WORD PTR [BP+0Ah]
r_si EQU WORD PTR [BP+08h]
r_di EQU WORD PTR [BP+06h]
r_ds EQU WORD PTR [BP+04h]
r_es EQU WORD PTR [BP+02h]
ges_int40 PROC
STI
CLD
PUSH AX
PUSH CX
PUSH DX
PUSH BX
PUSH BP
PUSH SI
PUSH DI
PUSH DS
PUSH ES
PUSH BP
MOV BP,SP
PUSH AX
MOV AX,40h
MOV DS,AX
POP AX
PUSH AX
MOV AL,AH
CMP AL,18h
JA mal_funcion
CMP AL,5
JBE func_oper
CMP AL,8
JNE func_aux?
MOV AL,6
JMP func_oper
func_aux?: CMP AL,15h
JB mal_funcion
SUB AL,0Eh
func_oper: CBW
MOV DI,AX
POP AX
SHL DI,1
JMP CS:tab_jmp[DI] ; ejecutar función
main_exit: MOV AL,AH ; preservar resultado
LAHF ; preservar flags
PUSH AX
PUSH AX
MOV AX,40h
MOV DS,AX
POP AX
MOV AL,r_dl ; DL a la llamada (unidad)
CMP AL,1
JA u_det ; unidad incorrecta
XOR AH,AH
MOV BX,90h
ADD BX,AX ; [BX] -> estado físico unidad
TEST BYTE PTR DS:[BX],10h ; ¿densidad determinada?
JZ u_det ; no
MOV DL,4 ; sí
MUL DL
MOV CL,AL
SHL DL,CL
OR DS:[8Fh],DL ; unidad determinada
u_det: POP AX
SAHF ; recuperar flags
MOV AH,AL ; recuperar resultado
exit_i40: MOV r_ah,AH ; AH para la salida del IRET
MOV AX,201H ; STI + STC en flags
JC set_err ; hay error
AND r_flags_l,0FEH ; CLC (si no hay error)
DEC AX ; dejar sólo STI
set_err: OR r_flags,AX ; flags a la salida del IRET
POP BP
POP ES
POP DS
POP DI
POP SI
POP BP
POP BX
POP DX
POP CX
POP AX ; registros con resultado
IRET
ges_int40 ENDP
mal_funcion: POP AX
MOV AH,1 ; función/parámetro incorrecto
MOV DS:[41h],AH ; código de error
STC ; condición de error
JMP exit_i40
; ------------ Función 0: Resetear el sistema de disco.
reset PROC
CALL full_init ; inicialización plena
MOV DS:[41h],AH ; código de error
MOV AL,AH ; preservar código
LAHF ; preservar flags
PUSH AX
PUSH DS
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV CL,[SI+2]
POP DS
MOV DS:[40h],CL ; tics para detención motor
POP AX
SAHF
MOV AH,AL ; restaurado código y flags
JMP exit_i40
reset ENDP
; ------------ Inicialización plena.
full_init PROC
AND BYTE PTR DS:[3Eh],0F0h ; futuro recalibramiento
JMP init_fdc ; inicializar FDC
fdc_init: JC init_end
JMP send_specify ; enviar specify
specify_sent: JC init_end
XOR AH,AH ; no hay error
init_end: RET
full_init ENDP
; ------------ Función 1: Obtener resultado de la última operación.
get_status PROC
MOV AH,DS:[41h]
OR AH,AH
JZ no_err
STC
no_err: JMP exit_i40
get_status ENDP
; ------------ Función 15h: Obtener el tipo de disco.
get_disk_type PROC
CMP DL,1
JBE gdt_ok
MOV AH,1 ; función/parámetro incorrecto
STC
MOV DS:[41h],AH ; código de error
JMP gdt_exit
gdt_ok: MOV BX,90h
XOR DH,DH
ADD BX,DX ; [BX] -> estado físico unidad
MOV BL,[BX] ; estado físico de la unidad
OR BL,BL
JNZ gdt_posible
XOR AH,AH ; no existe tal unidad
JMP gdt_bye
gdt_posible: AND BL,7
JZ gdt_without ; 360K
CMP BL,3
JE gdt_without ; 360K
MOV AH,2
JMP gdt_bye ; con soporte cambio de línea
gdt_without: MOV AH,1 ; sin soporte cambio de línea
gdt_bye: CLC
MOV BYTE PTR DS:[41h],0 ; siempre sin error
gdt_exit: JMP main_exit
get_disk_type ENDP
; ------------ Función 17h: Establecer tipo de soporte para formateo.
set_type_fmt PROC
XOR AH,AH
CMP DL,1
JBE set_tp
set_tp_bad_p: MOV AH,1 ; función/parámetro incorrecto
set_tp_err: MOV DS:[41h],AH ; código de error
STC
JMP set_tp_exit
set_tp: CMP AL,0 ; validar parámetro
JE set_tp_bad_p
CMP AL,4
JA set_tp_bad_p
MOV BX,90h
XOR DH,DH
ADD BX,DX ; [BX] -> estado físico unidad
CMP AL,1 ; ¿360K en 360K?
JNE set_tp_n360
MOV BYTE PTR DS:[BX],93h ; actualizar variable tipo
MOV BYTE PTR DS:[41h],0 ; anular errores previos
JMP set_tp_t_exit
set_tp_n360: MOV CX,AX
PUSH BX
CALL motor_on ; arrancar motor
POP SI
PUSH SI
CALL read_disk_chg ; ¿cambio de disco?
POP BX
CMP AH,6 ; (0: no, 6: sí)
JBE set_tp_cd ; haya cambio o no
CMP AH,80h
JNE set_tp_cd ; sí existe disco
CMP BYTE PTR DS:[BX],97h ; ¿250 Kbps y no es 5.25?
JE set_tp_err ; error
MOV BYTE PTR DS:[BX],61h ; 300 Kbps, try 360 en 1.2
JMP set_tp_err ; error
set_tp_cd: CMP CL,4 ; ¿720K en 720K?
JNE set_tp_n720 ; no
MOV BYTE PTR DS:[BX],97h ; actualizar variable tipo
JMP set_tp_t_exit
set_tp_n720: CMP CL,2 ; ¿360K en 1.2M?
JNE set_tp_ndd ; no
MOV BYTE PTR DS:[BX],74h ; actualizar variable tipo
JMP set_tp_t_exit
set_tp_ndd: MOV BYTE PTR DS:[BX],15h ; 1.2M en 1.2M
set_tp_t_exit: OR AH,AH ; comprobar posible error
JNZ set_tp_err
MOV BYTE PTR DS:[41h],0
set_tp_exit: JMP main_exit
set_type_fmt ENDP
; ------------ Función 16h: Detectar cambio de disco.
detect_change PROC
CMP DL,1
JBE det_ch
MOV AH,1 ; función/parámetro incorrecto
det_ch_r_err: STC
JMP det_ch_end
det_ch: XOR DH,DH
MOV BX,90h
ADD BX,DX ; [BX] -> estado físico
CMP BYTE PTR DS:[BX],0 ; ¿estado indeterminado?...
MOV AH,80h ; "unidad no preparada"
JE det_ch_r_err ; ...en efecto
MOV AH,[BX]
AND AH,7
JZ det_ch_yes ; 360K en 360K, no es posible
CMP AH,3
JNE det_ch_calc ; no es 360K en 360K
det_ch_yes: MOV AH,6 ; hay cambio (o desconocido)
STC
JMP det_ch_end
det_ch_calc: CALL motor_on ; arrancar motor
MOV DX,3F7h
IN AL,DX ; leer línea de cambio de disco
SHL AL,1
JC det_ch_yes ; hay cambio de disco
XOR AH,AH ; no lo hay
det_ch_end: MOV DS:[41h],AH ; actualizar código de error
PUSH AX
PUSH SI
PUSH DS
MOV SI,0
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV AL,[SI+2]
POP DS
MOV DS:[40h],AL ; tiempo detención motor
POP SI
POP AX
JMP main_exit
detect_change ENDP
; ------------ Funciones 2, 3 y 4: Leer, escribir y verificar.
read_wr_verify PROC
CMP DL,1
JBE rwv_posible
MOV AH,1 ; función/parámetro incorrecto
rwv_err: MOV DS:[41h],AH ; código de error
XOR AL,AL
STC
JMP rwv_exit
rwv_posible: MOV SI,90h
PUSH DX
XOR DH,DH
ADD SI,DX ; [SI] -> estado físico
CMP BYTE PTR DS:[SI],0 ; ¿estado indeterminado?...
POP DX
JNE rwv_state_ok ; no
PUSH AX
CALL get_drive_type ; obtener tipo disquetera en AL
JZ rwv_type_ok ; ha resultado posible
POP AX
rwv_not_ready: MOV AH,80h ; "unidad no preparada"
JMP rwv_err
rwv_type_ok: OR AL,AL ; ¿existe la unidad?
POP AX
JZ rwv_not_ready ; no existe esa unidad
MOV BYTE PTR DS:[SI],2 ; probando 1.2M en 1.2M
rwv_state_ok: MOV DI,3Fh
AND BYTE PTR DS:[DI],7Fh ; operación Read/Verify
CMP AH,3 ; ¿operación de escritura?
JNE rwv_nowr
OR BYTE PTR DS:[DI],80h ; operación Write/Format
rwv_nowr: PUSH SI
CALL get_drive_type ; obtener tipo disquetera en AL
JNZ rwv_media_ok
CMP AL,1
JE rwv_set360 ; es de 360K
CMP AL,3
JNE rwv_media_ok ; no es de 720K
MOV BYTE PTR DS:[SI],97h ; forzar medio de 720K
JMP rwv_media_ok
rwv_set360: MOV BYTE PTR DS:[SI],93h ; forzar medio de 360K
rwv_media_ok: CALL motor_on ; arrancar motores
CALL read_disk_chg ; leer línea de cambio de disco
POP SI
JNC rwv_no_dschg ; no hay cambio de disco
rwv_end_err: CALL end_io_access
JMP rwv_err
rwv_no_dschg: TEST BYTE PTR DS:[SI],10h ; ¿densidad determinada?
JNZ rwv_set_rate ; en efecto
CALL detect_media ; pues determinarla
JC rwv_end_err ; problemas
JMP rwv_dens_ok
rwv_set_rate: CALL select_rate ; seleccionar la velocidad
rwv_dens_ok: MOV SI,90h
PUSH DX
XOR DH,DH
ADD SI,DX ; [SI] -> estado físico unidad
POP DX
MOV AX,0AF03H ; AF byte 0 specify 2.88
CMP BYTE PTR DS:[SI],0D7h ; ¿2.88M?
JE rwv_spec_ok ; así es
MOV AX,0DF03h ; DF para 360/1.2/720
CMP BYTE PTR DS:[SI],17h ; ¿1.44M?
JNE rwv_spec_ok ; no
MOV AH,0BFh ; sí
rwv_spec_ok: MOV SI,AX ; SI 0-7: orden specify
MOV DI,2 ; DI 0-7: byte 1 specify
MOV CH,3 ; comando de 3 bytes
OR BYTE PTR DS:[3Eh],80h ; no esperar INT
CALL exec_cmd
JC rwv_end_err ; fallo
MOV AX,r_ax
XOR AH,AH
PUSH DS
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV CL,r_AL
ADD CL,r_CL ; [*] último sector a acceder
MOV [SI+4],CL
MOV CL,[SI+3] ; bytes/sector
SHL AL,CL ; multiplicar por nº sectores
MOV CL,80h
MUL CL ; y por 128
POP DS
DEC AX ; un byte menos...
MOV CX,AX ; ...cuenta para el DMA
CALL eval_dir_DMA
JNC rwv_dma_ok ; no hay problemas con el DMA
MOV CX,r_cx ; restaurar CX
JMP rwv_end_err ; problemas con el DMA
rwv_dma_ok: MOV AX,r_ax
CMP AH,2 ; ¿operación de lectura?
JNE rwv_no_read
MOV AH,46h ; byte de modo DMA para lectura
JMP rwv_dma_set
rwv_no_read: CMP AH,3 ; ¿escritura?
MOV AH,4Ah ; modo DMA para escritura
JZ rwv_dma_set
MOV AH,42h ; modo DMA para verificación
rwv_dma_set: CALL set_dma ; preparar DMA
MOV AX,r_ax
MOV CX,r_cx ; restaurar parámetros
JMP perform_io ; efectuar E/S
io_performed: CALL end_io_access
OR AL,AL
JZ rwv_end
SUB BL,CL ; próximo sector-sector inicial
MOV AL,BL ; nº sectores transferidos
rwv_end: MOV AH,DS:[41h]
OR AH,AH ; ¿error?
JZ rwv_exit
STC ; señalizar error
rwv_exit: MOV r_al,AL ; nº sectores transferidos
JMP main_exit
read_wr_verify ENDP
; ------------ Función 5: Formatear pista.
format_track PROC
CMP DL,1
JBE fmt_do
MOV AH,1 ; función/parámetro incorrecto
fmt_exit_err: MOV DS:[41h],AH ; código de error
STC
JMP main_exit
fmt_do: MOV SI,90h
PUSH DX
XOR DH,DH
ADD SI,DX ; [SI] -> estado físico unidad
POP DX
CMP BYTE PTR DS:[SI],0
MOV AH,80h ; "unidad no preparada"
JE fmt_exit_err ; indeterminado
MOV DI,3Fh
OR BYTE PTR DS:[DI],80h ; no esperar INT
CALL motor_on ; arrancar motores
CALL read_disk_chg ; leer línea de cambio de disco
JNC fmt_posible ; no hay cambio de disco
fmt_err: CALL end_io_access
JMP fmt_exit_err ; error
fmt_posible: CALL select_rate ; seleccionar la velocidad
CALL send_specify ; enviar comando specify
PUSH DS
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV AL,r_AL
MOV [SI+4],AL ; [*] sectores por pista
POP DS
XOR AH,AH
MOV CL,4
MUL CL ; 4 bytes para cada uno
MOV CX,AX
DEC CX ; un byte menos...
CALL eval_dir_DMA ; ...cuenta para el DMA
JC fmt_err ; cruza frontera de DMA
MOV AH,4Ah ; modo DMA para escritura
CALL set_dma ; preparar DMA
MOV CX,r_cx ; restaurar CX
CALL seek ; llevar el cabezal a la pista
JNC fmt_continue ; no hay problemas
fmt_err_res: MOV BX,42h
MOV CX,7
PUSH AX
CALL get_results ; leer bytes de resultados
POP AX
JMP fmt_exit ; error
fmt_continue: XSHL DH,2
OR DH,DL ; DH = byte 1 del comando
MOV DL,0CDh ; comando de formateo del FDC
PUSH DS
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
PUSH AX
MOV AX,[SI+7] ; GAP formateo/byte de relleno
MOV [BP],AX ; preservarlo
POP AX
MOV DI,[SI+3] ; bytes/sector, sectores/pista
POP DS
MOV SI,DX ; primeros bytes del comando
MOV CH,6 ; comando de 6 bytes
AND BYTE PTR DS:[3Eh],7Fh ; con espera de IRQ
CALL exec_cmd
JC fmt_err_res ; hay error
MOV BX,42h
MOV CX,7
CALL get_results ; leer bytes de resultados
JC fmt_exit
CALL get_bios_err ; obtener código de error
fmt_exit: MOV DS:[41h],AH ; código de error
CALL end_io_access
MOV AH,DS:[41h]
OR AH,AH
JZ fmt_end ; no hay error
STC
fmt_end: JMP main_exit
format_track ENDP
; ------------ Función 8: Obtener parámetros de disco.
get_drv_param PROC
CMP DL,80h
JB gdrv_do
MOV AH,1 ; función/parámetro incorrecto
MOV DS:[41h],AH ; código de error
STC
JMP main_exit
gdrv_do: XOR DI,DI
XOR SI,SI
XOR DH,DH
MOV AL,DS:[10h] ; hardware instalado
AND AL,0C1h ; nº disqueteras (7-6) y bit
MOV DI,2 ; que indica arrancable (0)
CMP AL,41h ; ¿dos disqueteras? (DI=2)
JE gdrv_ndisk_ok ; en efecto
DEC DI
CMP AL,1 ; ¿una disquetera? (DI=1)
JE gdrv_ndisk_ok ; así es
JMP gdrv_res_null ; no hay disqueteras
gdrv_ndisk_ok: CMP DL,1
JBE gdrv_a_or_b ; la disquetera es A: o B:
JMP gdrv_half_res
gdrv_a_or_b: CALL peek_cmos ; leer tipo de disqueteras
OR DL,DL
JNZ gdrv_sel
MOV CL,4
SHR AL,CL ; dejar disquetera en bits 0-3
gdrv_sel: AND AL,0Fh
JZ gdrv_media? ; no existe esa unidad
CMP AL,5
JA gdrv_media? ; es mayor de 2.88M
XOR AH,AH
MOV SI,AX
MOV DH,AL
MOV BX,90h
ADD BL,DL ; [BX] -> estado físico unidad
MOV AL,[BX]
TEST AL,10h ; ¿densidad determinada?
JNZ gdrv_calc_p ; en efecto
CMP SI,1 ; ¿unidad de 360K?
MOV AL,93h ; 360K en 360K, 250 Kbps
JE gdrv_media_ok
CMP SI,2 ; ¿unidad de 1.2M?
MOV AL,2 ; "intentando 1.2M"
JE gdrv_media_ok
CMP SI,3 ; ¿unidad de 720K?
MOV AL,97h ; 720K en 720K, 250 Kbps
JE gdrv_media_ok
CMP SI,4 ; ¿unidad de 1.44M?
MOV AL,7 ; "intentando 1.44M"
JE gdrv_media_ok
MOV AL,0C7h ; 2.88M en 2.88M
gdrv_media_ok: MOV [BX],AL
JMP gdrv_calc_p ; medio físico asignado
gdrv_media?: MOV BX,90h
ADD BL,DL ; [BX] -> estado físico unidad
MOV AL,[BX]
TEST AL,10h ; ¿densidad determinada?
JZ gdrv_eval ; no
MOV AH,AL
AND AL,0C0h ; aislar bits de velocidad
CMP AL,80h ; ¿250 Kbps?
MOV SI,2 ; 1.2M
JNE gdrv_m144?
TEST AH,4
MOV SI,1 ; 360K
JZ gdrv_calc_p
MOV SI,4 ; 1.44M
gdrv_m144?: TEST AH,7
JZ gdrv_calc_p
MOV SI,4 ; 1.44M
gdrv_calc_p: MOV BX,DI
MOV DI,SI
DEC DI
ADD DI,DI
MOV AX,CS:tab_disksize[DI] ; AL sect/pista, AH pistas
MOV r_dh,1 ; dos cabezales
MOV DI,CS:tab_ptr_1e[DI] ; DI -> tabla parámetros
PUSH CS
POP ES ; ES:DI -> parámetros disco
gdrv_set_res: MOV r_dl,BL ; número de unidades
MOV r_ch,AH ; mayor número de cilindro
MOV r_cl,AL ; mayor número de sector
MOV r_bl,DH ; tipo de la unidad
MOV r_bh,0
MOV r_es,ES ; ES:DI para la salida
MOV r_di,DI
XOR AX,AX
MOV DS:[41h],AH ; resultado correcto
MOV r_al,AL
JMP main_exit
gdrv_res_null: XOR DI,DI ; devolver todo a 0
gdrv_half_res: XOR DH,DH
XOR AX,AX
MOV ES,AX
MOV r_dh,0
MOV BX,DI
XOR DI,DI
JMP gdrv_set_res ; resultado trivial
gdrv_eval: MOV BX,DI
OR SI,SI
JZ gdrv_res_null ; no existe la unidad
CMP SI,3
JBE gdrv_calc_p ; es de 5¼
XOR SI,SI
JMP gdrv_res_null
get_drv_param ENDP
; ------------ Función 18h: Establecer densidad de formateo.
set_media_fmt PROC
CMP DL,1
JBE setm_do
MOV AH,1 ; función/parámetro incorrecto
setm_exit_err: STC
JMP main_exit
setm_do: CALL get_drive_type ; obtener tipo disquetera en AL
JZ setm_drv_ok
setm_drv_unkn: MOV AH,0Ch ; tipo de unidad desconocido
JMP setm_exit_err
setm_drv_ok: XOR AH,AH
MOV DI,AX ; tipo de unidad
MOV DL,r_dl
MOV BX,90h
XOR DH,DH
ADD BX,DX ; [BX] -> estado físico unidad
CMP AL,1 ; ¿360K?
JNE setm_not360
MOV CX,r_cx ; restaurar CX
CMP CX,2709h ; ¿40 pistas 9 sectores?
LEA SI,t360in360
JNZ setm_drv_unkn ; sólo se permite ese formato
JMP setm_360in360
setm_not360: CMP AL,3 ; ¿720K?
JNE setm_not720
MOV CX,r_cx ; restaurar CX
CMP CX,4F09h ; ¿80 pistas 9 sectores?
JNE setm_drv_unkn ; sólo se permite ese formato
JMP setm_setm
setm_not720: CMP AL,4 ; ¿1.44M?
JE setm_1440
CMP AL,2 ; ¿1.2M?
JE setm_1200
CMP AL,5 ; ¿2.88M?
JNE setm_drv_unkn
MOV CX,r_cx ; 2.88M: restaurar CX
CMP CX,4F24h ; ¿80 pistas 36 sectores?
JE setm_setm ; correcto
CMP CX,4F12h ; ¿80 pistas 18 sectores?
JE setm_setm ; correcto
CMP CX,4F09h ; ¿80 pistas 9 sectores?
JE setm_setm ; correcto
JMP setm_drv_unkn ; permitir sólo esos formatos
setm_1200: MOV CX,r_cx ; restaurar CX
CMP CX,4F0Fh ; ¿80 pistas 15 sectores?
JE setm_setm ; correcto
CMP CX,2709h ; ¿80 pistas 9 sectores?
JNE setm_drv_unkn ; permitir sólo esos formatos
JMP setm_setm ; correcto
setm_1440: MOV CX,r_cx ; restaurar CX
CMP CX,4F12h ; ¿80 pistas 18 sectores?
JE setm_setm ; correcto
CMP CX,4F09h ; ¿80 pistas 9 sectores?
JNE setm_drv_unkn ; permitir sólo esos formatos
setm_setm: MOV CX,r_cx ; restaurar CX
CMP CX,4F12h ; ¿80 pistas 18 sectores?
MOV AL,17h ; su byte de medio físico
LEA SI,t1440 ; es 1.44M
MOV DH,0 ; 500 Kbps
JZ setm_m_ok
CMP CX,4F09h ; ¿80 pistas 9 sectores?
MOV AL,97h ; su byte de medio físico
LEA SI,t720 ; es 720K
MOV DH,2 ; 250 Kbps
JZ setm_m_ok
CMP CX,4F0Fh ; ¿80 pistas 15 sectores?
MOV AL,15h ; su byte de medio físico
LEA SI,t1200 ; es 1.2M
MOV DH,0 ; 500 Kbps
JZ setm_m_ok
CMP CX,4F24h ; ¿80 pistas 36 sectores?
MOV AL,0D7h ; su byte de medio físico
LEA SI,t2880 ; es 2.88M
MOV DH,3 ; 1 Mbps
JZ setm_m_ok
MOV AL,74h ; byte medio físico 360K en 1.2
LEA SI,t360en1200 ; es 360K en 1.2M
MOV DH,1 ; 300 Kbps
setm_m_ok: MOV [BX],AL ; establecer medio físico
PUSH DX
CALL set_rate ; velocidad de transferencia DH
POP DX
MOV AL,[BX]
AND AL,0C0h
AND BYTE PTR DS:[8Bh],3Fh ; borrar bits de velocidad
OR BYTE PTR DS:[8Bh],AL ; nueva velocidad
MOV r_di,SI
MOV r_es,CS ; retornar tabla parámetros
MOV BYTE PTR DS:[41h],0 ; no hay error
XOR AH,AH
JMP main_exit
setm_360in360: MOV DH,2 ; 250 Kbps
MOV AL,93h ; 360K en 360K
JMP setm_m_ok
set_media_fmt ENDP
; ------------ Recalibrar.
recalibrate PROC
PUSH SI
PUSH CX
PUSH DX
MOV DH,DL
MOV DL,7 ; comando "recalibrate"
MOV SI,DX
MOV CH,2 ; comando de 2 bytes
AND BYTE PTR DS:[3Eh],7Fh ; con espera de IRQ
CALL exec_cmd
JC recal_end ; fallo
MOV SI,8 ; "leer estado interrupciones"
MOV CH,1 ; comando de 1 byte
OR BYTE PTR DS:[3Eh],80h ; sin espera de IRQ
CALL exec_cmd
JC recal_end ; fallo
MOV BX,42h
MOV CX,2 ; 2 bytes de resultado
CALL get_results ; almacenar resultado
JC recal_end ; fallo
MOV BX,42h
MOV AH,40h
MOV DL,[BX] ; ST0
AND DL,60h
CMP DL,60h ; ¿terminación anormal y
STC ; seek-end?
JE recal_end ; fallo
POP DX
PUSH DX
XOR DH,DH
MOV BX,94H
ADD BX,DX
MOV BYTE PTR DS:[BX],0 ; cilindro en curso = 0
MOV CL,DL
MOV DL,1
SHL DL,CL
OR DS:[3Eh],DL ; unidad recalibrada
MOV CX,1
CALL retardo ; retardo de 1 ms
XOR AH,AH
recal_end: MOV DS:[41h],AH ; código de error / acierto
POP DX
POP CX
POP SI
RET
recalibrate ENDP
; ------------ Llevar el cabezal al cilindro adecuado.
seek PROC
PUSH BX
PUSH CX
MOV AH,DS:[3Eh] ; estado de recalibración
MOV CL,DL
INC CL
SHR AH,CL
JC seek_only
CALL recalibrate ; hay que recalibrar
JNC seek_only
CALL recalibrate ; segundo intento
JNC seek_only
JMP seek_exit
seek_only: MOV BX,94H
XOR DH,DH
ADD BX,DX ; [BX] -> cilindro actual
MOV SI,90h
ADD SI,DX ; [SI] -> estado físico unidad
MOV DL,CH
TEST BYTE PTR DS:[SI],20h ; ¿hacer double stepping?
JZ seek_cil_ok1
ADD DL,DL ; sí: cilindro=cilindro*2
seek_cil_ok1: CMP [BX],DL ; ¿ya estamos en ese cilindro?
MOV DX,r_dx
JNE seek_do ; aún no
CMP BYTE PTR DS:[41h],40h ; ¿hubo "seek error"?
JE seek_do
XOR AH,AH ; no, seek innecesario
JMP seek_exit
seek_do: XSHL DH,2
OR DH,DL ; byte 1 del comando seek
MOV DL,0FH ; orden seek
MOV SI,DX
MOV CL,CH ; cilindro
MOV DX,r_dx ; unidad / cabezal
MOV BX,90h
XOR DH,DH
ADD BX,DX ; [BX] -> estado físico
TEST BYTE PTR DS:[BX],20h ; ¿hacer double stepping?
JZ seek_cil_ok2 ; no
ADD CL,CL ; sí: cilindro=cilindro*2
seek_cil_ok2: MOV DI,CX
MOV CH,3 ; comando de 3 bytes
AND BYTE PTR DS:[3Eh],7Fh ; hay que esperar IRQ
CALL exec_cmd
JNC seek_ok ; seek correcto
JMP seek_result
seek_ok: MOV SI,8 ; "leer estado interrupciones"
MOV CH,1 ; comando de 1 byte
OR BYTE PTR DS:[3Eh],80h ; no hay que esperar IRQ
CALL exec_cmd
JC seek_result ; fallo
MOV BX,42h
MOV CX,2
CALL get_results ; leer bytes de resultados
JC seek_result
MOV BX,42h
MOV AH,40h ; "seek error"
MOV DL,[BX] ; ST0
AND DL,60h
CMP DL,60h ; comprobarlo
STC
JE seek_result ; terminación brusca
MOV DX,r_dx ; restaurar DX
POP CX
PUSH CX ; restaurar CX
MOV SI,94H
XOR DH,DH
ADD SI,DX
MOV [SI],CH ; actualizar cilindro actual
MOV BX,90h
ADD BX,DX ; [BX] -> estado físico unidad
MOV BL,[BX]
TEST BL,20h ; ¿double stepping?
JZ seek_cil_ok3
ADD [SI],CH ; pues cilindro*2
seek_cil_ok3: PUSH DS
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV AL,[SI+9] ; tiempo estabilización cabezal
POP DS
TEST BYTE PTR DS:[3Fh],80h ; ¿operación en curso?
JZ seek_wait ; es lectura o verificación
OR AL,AL
JNZ seek_wait ; escritura, cte != 0
CMP BL,17h
MOV AL,0Fh
JE seek_wait ; 15 ms excepto para 360K
AND BL,7
MOV AL,14h
JZ seek_wait ; 20 ms para unidades de 360K
CMP BL,3
JE seek_wait ; 20 ms para unidades de 360K
MOV AL,0Fh ; 15 ms para demás unidades
seek_wait: OR AL,AL
JZ seek_wait_end
MOV CX,1
CALL retardo ; esperar 1 ms...
DEC AL
JMP seek_wait ; ...durante AL veces
seek_wait_end: XOR AH,AH
seek_result: MOV DS:[41h],AH ; resultado
seek_exit: MOV DX,r_dx ; restaurar DX
POP CX
POP BX
RET
seek ENDP
; ------------ Ejecutar operación de E/S a través del FDC.
perform_io PROC
CALL seek
JNC p_io
p_io_dsk_err: MOV AL,0 ; fallo
PUSH AX
MOV BX,42h
MOV CX,7
CALL get_results ; leer bytes de resultados
POP AX
JMP p_io_exit
p_io: PUSH DS ; preparar bytes comando R/W
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV AX,[SI+2]
AND AX,0FF00h ; AH = bytes por sector
MOV AL,CL ; AL = primer sector
MOV [BP],AX
MOV BX,[SI+4] ; BL=sectores/pista, BH=GAP R/W
MOV CL,[SI+6] ; CL=longitud de sector (tam=0)
POP DS
MOV SI,90h
XOR DH,DH
ADD SI,DX ; nº sector/tamaño (bytes 4-5)
MOV DL,[SI] ; estado físico de la unidad
AND DL,7
MOV DH,1Bh ; GAP R/W para 1.2M/1.44M/2.88M
CMP DL,5
JE p_io_gap_ok ; 1.2M en 1.2M
CMP BYTE PTR DS:[SI],17h
JE p_io_gap_ok ; 1.44M
CMP BYTE PTR DS:[SI],0D7h
JE p_io_gap_ok ; 2.88M
MOV DH,23h ; GAP R/W para 360K en 1.2M
CMP DL,4
JE p_io_gap_ok ; 360K en 1.2M
MOV DH,2Ah ; GAP R/W para demás casos
p_io_gap_ok: MOV BH,DH ; BX=numsect/GAP (bytes 6-7)
MOV DX,r_dx ; restaurar DX
PUSH CX
MOV CL,CH ; cilindro
MOV CH,DH ; cabezal
MOV DI,CX ; cabezal/cilindro (bytes 2-3)
XSHL DH,2
OR DH,DL ; byte 1 de comando FDC
MOV DL,0E6h ; comando leer datos
MOV AX,r_ax ; orden
CMP AH,3 ; ¿write?
JNE p_io_orden_ok
MOV DL,0C5h ; comando escribir datos
p_io_orden_ok: MOV SI,DX ; (bytes 0-1 de la orden)
POP CX
MOV CH,9
AND BYTE PTR DS:[3Eh],7Fh ; esperar interrupción
CALL exec_cmd
JNC p_io_dsk_ok
JMP p_io_dsk_err ; fallo
p_io_dsk_ok: MOV BX,42h
MOV CX,7
CALL get_results ; leer bytes de resultados
JNC p_io_res_ok
MOV AL,0
JMP p_io_exit ; fallo: respetar código error
p_io_res_ok: CALL get_bios_err
p_io_exit: MOV DS:[41h],AH
MOV DX,r_dx ; restaurar registros
MOV BX,r_bx
MOV CX,r_cx
JMP io_performed ; continuar operación E/S
perform_io ENDP
; ------------ Arrancar motor si no lo está.
motor_on PROC
PUSH DX
PUSH CX
CLI ; * evitar reentrada
MOV BYTE PTR DS:[40h],0FFh ; evitar detención motor
AND BYTE PTR DS:[3Fh],0CFh ; a 0 bits de disquetera
MOV CH,DL
XSHL DL,4
OR DS:[3Fh],DL ; nueva disquetera seleccionada
MOV CL,CH
MOV DL,DS:[3Fh] ; estado de motores
INC CL
SHR DL,CL
JC motor_is_on ; motor ya en marcha
MOV DL,1
DEC CL
SHL DL,CL
OR DS:[3Fh],DL ; señalizar que está en marcha
STI ; * fin de la fase crítica
MOV AL,DS:[3Fh] ; estado de motores
XROR AL,4
OR AL,0CH ; no resetear, modo DMA
MOV DX,3F2h
OUT DX,AL ; registro salida digital
MOV AX,90FDh
INT 15h ; permitir multitarea
JC motor_on_end
MOV AH,DS:[3Fh]
PUSH DS
PUSH SI
XOR SI,SI
MOV DS,SI
LDS SI,DWORD PTR DS:[78h] ; DS:SI -> INT 1Eh
MOV AL,[SI+0Ah]
POP SI ; AL = tiempo aceleración motor
POP DS ; en octavos de segundo
SHL AH,1
JNC motor_on_rv ; operación read/verify
CMP AL,8
JAE motor_on_wait
MOV AL,8
JMP motor_on_wait ; escritura: al menos 1 segundo
motor_on_rv: CMP AL,5
JAE motor_on_wait
MOV AL,5 ; read/verify: al menos 625 ms
motor_on_wait: MOV CX,125
CALL retardo ; retardo de unos 125 ms
DEC AL
JNZ motor_on_wait ; completar retardo
JMP motor_on_end
motor_is_on: STI
MOV AL,DS:[3Fh] ; estado de motores
XROR AL,4
OR AL,0CH ; no resetear, modo DMA
MOV DX,3F2h
OUT DX,AL ; seleccionar unidad
motor_on_end: POP CX
POP DX
RET
motor_on ENDP
; ------------ Asignar cuenta para detención motor y devolver en BL
; y AL el próximo número de sector a transferir.
end_io_access PROC
PUSH AX
PUSH DS
XOR BX,BX
MOV DS,BX
LDS BX,DWORD PTR DS:[78h] ; DS:BX -> INT 1Eh
MOV AH,[BX+2] ; tics hasta detención motor
MOV AL,[BX+4]
INC AL ; sectores/pista + 1
POP DS
MOV BX,42h
CMP CH,[BX+3] ; ¿mismo cilindro resultante?
JNE end_io_exit
CMP DH,[BX+4] ; ¿mismo cabezal resultante?
JNE end_io_exit
MOV AL,[BX+5] ; número de sector resultante
end_io_exit: MOV DS:[40h],AH ; tiempo para detención motor
MOV BL,AL ; último nº sector transferido
POP AX
RET
end_io_access ENDP
; ------------ Leer la línea de cambio de disco y bajarla si está
; activa.
read_disk_chg PROC
PUSH CX
CALL get_drive_type ; obtener tipo disquetera en AL
MOV AH,0
JNZ fallo_cmos
DEC AL
JZ rdchg_set_cod ; evitar test en 360K
fallo_cmos: MOV AL,[SI] ; estado físico de la unidad
AND AL,7
JZ rdchg_set_cod ; evitar test en 360K
CMP AL,3
JE rdchg_set_cod ; evitar test en 360K
MOV DX,3F7h ; registro de entrada digital
IN AL,DX ; leer línea de cambio de disco
SHL AL,1
JNC rdchg_exit ; no hay cambio de disco
AND BYTE PTR DS:[SI],0EFH ; medio no determinado
CALL full_init ; inicialización plena
JC rdchg_exit ; fallo
MOV DX,r_dx ; restaurar DX
MOV CH,1
CALL seek ; cabezal a cilindro 1
JC rdchg_exit
MOV CH,0
CALL seek ; cabezal a cilindro 0
JC rdchg_exit
MOV AH,6 ; error "disk changed"
MOV DX,3F7h
IN AL,DX ; leer línea de cambio de disco
SHL AL,1
JNC rdchg_set_cod ; se ha podido bajar
MOV AH,80h ; no se pudo: no hay disquete
rdchg_set_cod: OR AH,AH
JZ rdchg_exit
STC
rdchg_exit: MOV DX,r_dx ; restaurar DX
POP CX
RET
read_disk_chg ENDP
; ------------ Programar el DMA para efectuar la E/S.
set_dma PROC
PUSH AX
PUSH DX
CLI
MOV AL,AH
OUT 0CH,AL ; clear first/last flip-flop
JCXZ $+2 ; retardo para E/S
JCXZ $+2
OUT 0BH,AL ; registro de modo del DMA
JCXZ $+2
JCXZ $+2
MOV AL,CL
OUT 5,AL
JCXZ $+2
JCXZ $+2
MOV AL,CH
OUT 5,AL ; enviada cuenta de bytes
JCXZ $+2
JCXZ $+2
MOV AL,BL
OUT 4,AL
JCXZ $+2
JCXZ $+2
MOV AL,BH
OUT 4,AL ; enviada dirección base
JCXZ $+2
JCXZ $+2
MOV AX,ES
OUT 81H,AL ; registro de página canal 2
JCXZ $+2
JCXZ $+2
MOV AL,2
OUT 0AH,AL ; habilitar canal 2 del DMA
STI
POP DX
POP AX
RET
set_dma ENDP
; ------------ Calcular parámetros para programar el DMA.
eval_dir_DMA PROC
PUSH CX
XOR AX,AX
MOV CX,ES ; segmento ES
SHL CX,1 ; desplazar...
RCL AL,1
SHL CX,1
RCL AL,1
SHL CX,1
RCL AL,1
SHL CX,1
RCL AL,1 ; ... AL:CX >> 4
MOV BX,r_bx ; offset BX
ADD BX,CX
ADC AX,0 ; AX:BX dirección física 20 bit
MOV ES,AX ; página de DMA
POP CX
MOV AX,CX
ADD AX,BX
JNC eval_dma_ret ; no cruza frontera de 64k
MOV AH,9 ; "DMA across 64k boundary"
eval_dma_ret: RET
eval_dir_DMA ENDP
; ------------ Enviar comando completo al FDC de CH bytes, contenido
; en SI, DI, [BP], BX y CL (parte baja - alta).
send_full_cmd PROC
MOV AX,SI
MOV AH,AL
CALL fdc_write ; enviar SI-L
DEC CH
JBE send_full_ret ; acabado (ZF=1) ó error (CF=1)
MOV AX,SI
CALL fdc_write ; enviar SI-H
DEC CH
JBE send_full_ret
MOV AX,DI
MOV AH,AL
CALL fdc_write ; enviar DI-L
DEC CH
JBE send_full_ret
MOV AX,DI
CALL fdc_write ; enviar DI-H
DEC CH
JBE send_full_ret
MOV AX,[BP]
MOV AH,AL
CALL fdc_write ; enviar [BP]-L
DEC CH
JBE send_full_ret
MOV AX,[BP]
CALL fdc_write ; enviar [BP]-H
DEC CH
JBE send_full_ret
MOV AH,BL
CALL fdc_write ; enviar BL
DEC CH
JBE send_full_ret
MOV AH,BH
CALL fdc_write ; enviar BH
DEC CH
JBE send_full_ret
MOV AH,CL
CALL fdc_write ; enviar CL
send_full_ret: RET
send_full_cmd ENDP
; ------------ Enviar comando al FDC con/sin espera de interrupción.
exec_cmd PROC
TEST BYTE PTR DS:[3Eh],80h ; ¿hay que esperar IRQ?
JZ exec_cmd_irq ; sí
AND BYTE PTR DS:[3Eh],7Fh ; no: devolver a 0 bit IRQ
CALL send_full_cmd ; enviar comando
RET
exec_cmd_irq: CALL send_full_cmd ; enviar comando
JC exec_cmd_ret
MOV AX,9001h
INT 15h ; permitir multitarea
STI
JC exec_cmd_err
CALL wait_int ; esperar IRQ
JNC exec_cmd_ok
exec_cmd_err: MOV AH,80h ; "not ready" (AH=80h)
exec_cmd_ret: RET
exec_cmd_ok: AND BYTE PTR DS:[3Eh],7Fh ; bit IRQ listo para otra
XOR AH,AH ; éxito
RET
exec_cmd ENDP
; ------------ Enviar byte al FDC.
fdc_write PROC
XPUSH <CX, DX, AX>
MOV DX,3F4h ; registro de estado del FDC
XOR CX,CX ; evitar cuelgue total si falla
espera_wr: IN AL,DX ; leer registro de estado
TEST AL,80h ; ¿bit 7 inactivo?
LOOPZ espera_wr ; así es: el FDC está ocupado
JCXZ fdc_wr_nok
POP AX
PUSH AX
INC DX ; apuntar al registro de datos
MOV AL,AH
OUT DX,AL ; enviar byte al FDC
XPOP <AX, DX, CX>
CLC
RET
fdc_wr_nok: POP AX
MOV AH,80h ; timeout
XPOP <DX, CX>
STC
RET
fdc_write ENDP
; ------------ Leer del FDC CX bytes de resultado en [BX++].
get_results PROC
PUSH DX
get_one_byte: PUSH CX
CALL fdc_read
POP CX
JC get_res_ret ; no hay más bytes que leer
MOV [BX],AL
INC BX
LOOP get_one_byte ; leer todos los bytes
CALL retardo53 ; retardo de 53 ms
MOV DX,3F4h
IN AL,DX ; leer registro de estado
TEST AL,10h
JZ get_res_ok ; el FDC no está ocupado
MOV AH,20h
STC ; lo estaba: "bad NEC"
JMP get_res_ret
get_res_ok: XOR AH,AH ; operación correcta
get_res_ret: POP DX
RET
get_results ENDP
; ------------ Leer byte del FDC.
fdc_read PROC
XPUSH <CX, DX>
MOV DX,3F4h ; registro de estado del FDC
XOR CX,CX ; evitar cuelgue total si falla
espera_rd: IN AL,DX ; leer registro de estado
TEST AL,80h ; ¿bit 7 inactivo?
LOOPZ espera_rd ; así es: el FDC está ocupado
JCXZ fdc_rd_nok
INC DX ; apuntar al registro de datos
IN AL,DX ; leer byte del FDC
CLC
XPOP <DX, CX>
RET
fdc_rd_nok: MOV AH,80h ; timeout
STC
XPOP <DX, CX>
RET
fdc_read ENDP
; ------------ Obtener código de error de la BIOS.
get_bios_err PROC
MOV BX,42h ; área de resultados del FDC
MOV BX,[BX]
TEST BL,0C0h ; ¿que tal ST0?
MOV AH,0
JZ bios_err_det ; ¡perfecto!
TEST BL,40h ; ¿terminación brusca/anormal?
MOV AH,20H ; "bad NEC"
JZ bios_err_det
TEST BH,1 ; ¿falta marca de direcciones?
MOV AH,2 ; "address mark not found"
JNZ bios_err_det
TEST BH,2 ; ¿protegido contra escritura?
MOV AH,3 ; "write-protect error"
JNZ bios_err_det
TEST BH,4 ; ¿sector no encontrado?
MOV AH,4 ; "sector not found"
JNZ bios_err_det
TEST BH,10H ; ¿DMA no atendido a tiempo?
MOV AH,8 ; "DMA overrun"
JNZ bios_err_det
TEST BH,20H ; ¿falla el CRC?
MOV AH,10H ; "CRC error"
JNZ bios_err_det
TEST BH,80h ; ¿acceso fuera de la pista?
MOV AH,4 ; "sector not found"
JNZ bios_err_det
MOV AH,20H ; otro error: "bad NEC"
bios_err_det: RET
get_bios_err ENDP
; ------------ Reinicializar la controladora de disquetes.
init_fdc PROC
CALL reset_disk ; resetear FDC
JC init_fin ; fallo al resetear
MOV DX,3F4h ; registro de estado del FDC
IN AL,DX
TEST AL,80h
JZ init_otravez ; el FDC no está listo
TEST AL,40h
JZ init_bien ; el FDC espera datos de la CPU
init_otravez: CALL reset_disk ; otro intento más
MOV DX,3F4h
IN AL,DX
TEST AL,80h
JZ init_mal ; nada, que no tira
TEST AL,40h
JZ init_bien ; bueno, ya despierta
init_mal: MOV AH,20h ; fallo de la controladora
STC
JMP init_fin
init_bien: MOV AH,8 ; "leer estado interrupciones"
CALL fdc_write ; enviar comando
JC init_fin ; fallo
CALL fdc_read ; leer ST0
JC init_fin ; fallo
MOV DS:[42h],AL ; guardar ST0
PUSH AX
CALL fdc_read ; leer cilindro actual
MOV DS:[42h+1],AL ; guardarlo
POP CX
JC init_fin ; fallo
AND CL,0C0h
CMP CL,0C0h ; ¿terminación anormal?
JNE init_mal ; no es terminación anormal
XOR AH,AH ; ok: el FDC detecta el fallo
init_fin: JMP fdc_init
init_fdc ENDP
; ------------ Resetear el FDC.
reset_disk PROC
CLI
AND BYTE PTR DS:[3Fh],7Fh ; operación R/V
AND BYTE PTR DS:[3Eh],7Fh ; borrar bit IRQ
MOV AL,DS:[3Fh]
XROL AL,4 ; bits 7-4: motores
AND AL,0FBH ; bits 3-0: unidad
OR AL,8 ; interrupciones ON + reset
MOV DX,3F2h
OUT DX,AL ; hacer reset
XOR CX,CX
CALL retardo53 ; pequeño retardo
OR AL,0CH
OUT DX,AL ; fin del reset
MOV AX,9001h
INT 15h ; facilitar multitarea
STI
JC fin_wait ; error
CALL wait_int ; esperar interrupción de disco
fin_wait: MOV AH,80h ; "unidad no preparada"
JC exit_reset ; hay error
AND BYTE PTR DS:[3Eh],7Fh ; borrar bit IRQ
XOR AH,AH ; no hay error
exit_reset: RET
reset_disk ENDP
; ------------ Enviar comando specify obtenido de INT 1Eh al FDC.
send_specify PROC
PUSH DS
XOR BX,BX
MOV DS,BX
LDS BX,DWORD PTR DS:[78h] ; DS:BX -> INT 1Eh
MOV AL,3 ; comando specify del FDC
MOV AH,[BX] ; byte 0 del comando specify
MOV SI,AX
MOV AL,[BX+1] ; byte 1 del comando specify
MOV DI,AX
MOV CH,3 ; orden de 3 bytes (SI, DI-L)
POP DS
OR BYTE PTR DS:[3Eh],80h ; no esperar IRQ
CALL exec_cmd ; mandar specify al FDC
JMP specify_sent
send_specify ENDP
; ------------ Esperar una interrupción de disco durante 2 segundos.
wait_int PROC
MOV BX,3Eh ; variable con flag de INT
MOV CX,37
CALL wait_event ; esperar IRQ durante 2 seg.
RET
wait_int ENDP
; ------------ Devolver en AL el tipo de la unidad DL.
get_drive_type PROC
CALL peek_cmos ; leer tipo de disqueteras
OR DL,DL
JNZ gdt_unidad_ok
XSHR AL,4 ; unidad A:
gdt_unidad_ok: AND AL,0Fh
CMP SP,SP ; ZF=1 -> resultado correcto
RET
get_drive_type ENDP
; ------------ Determinar la densidad del disquete.
detect_media PROC
PUSH DX
PUSH CX
PUSH BX
MOV BL,r_dl
XOR BH,BH
MOV DL,BL
CALL get_drive_type ; obtener tipo disquetera en AL
MOV AH,0
JZ dm_fast ; ha sido posible obtenerlo
JMP dm_slow ; usar procedimiento lento
dm_fast: MOV BYTE PTR DS:[BX+90h],0 ; estado físico unidad
DEC AX
JNZ dm_es_1200K?
MOV AL,93h ; 360K: 360K en 360K, 250 Kbps
dm_try: PUSH AX
MOV DH,AL
AND DH,0C0h
XSHR DH,6
CALL set_rate ; velocidad de transferencia DH
POP AX
dm_result: MOV DS:[BX+90h],AL ; estado físico...
TEST AL,10h ; ...¿determinado?
JZ dm_fails ; aún no
XOR AH,AH
JMP dm_exit ; sí: resultado correcto
NOP
dm_es_1200K?: DEC AX
JNZ dm_es_720K?
MOV AL,0
CALL read_ids ; 1.2M: 500 kbps
MOV AL,15h ; indicar 1.2M en 1.2M
JNC dm_result ; sí funciona
MOV AL,40h
MOV BYTE PTR DS:[BX+90h],2
CALL read_ids ; probar 300 Kbps
MOV AL,74h ; indicar 360K en 1.2M
JNC dm_result ; sí funciona
MOV AL,2 ; indicar "¿1.2M en 1.2M?"
JMP dm_result
dm_es_720K?: DEC AX
JNZ dm_es_1440K?
MOV AL,97h ; 720K: 250 Kbps
JMP dm_try ; a probar suerte
dm_es_1440K?: DEC AX
JNZ dm_es_2880K
MOV AL,0
CALL read_ids ; 1.44M: 500 Kbps
MOV AL,17h ; indicar 1.44M
JNC dm_result ; sí funciona
MOV AL,80h
CALL read_ids ; probar a 250 Kbps
MOV AL,97h ; indicar 720K
JNC dm_result ; sí funciona
MOV AL,7 ; indicar "¿1.44M?"
JMP dm_result
dm_es_2880K: MOV AL,0C0h
CALL read_ids ; 2.88M: 1 Mbps
MOV AL,0D7h ; indicar 2.88M en 2.88M
JNC dm_result ; sí funciona
MOV AL,0
CALL read_ids ; probar 500 Kbps
MOV AL,17h ; indicar 1.44M
JNC dm_result ; sí funciona
MOV AL,80h
CALL read_ids ; probar 250 Kbps
MOV AL,97h ; indicar 720K
JNC dm_result ; sí funciona
MOV AL,0C7h ; indicar "¿2.88M en 2.88M?"
JMP dm_result
dm_fails: STC ; condición de error
dm_exit: MOV DS:[41h],AH ; código de error
POP BX
POP CX
POP DX
RET
dm_slow: MOV AL,0
CALL read_ids ; probar 500 Kbps
MOV AL,15h ; indicar 1.2M en 1.2M
JNC dm_slow_ok ; sí funciona
MOV AL,40h
MOV BYTE PTR DS:[BX+90h],2
CALL read_ids ; probar 300 Kbps
MOV AL,74h ; indicar 360K en 1.2M
JNC dm_slow_ok ; sí funciona
MOV AL,80h
CALL read_ids ; probar 250 Kbps
MOV AL,97h ; indicar 720K ó 360K en 360K
JNC dm_slow_ok ; sí funciona
MOV AL,0C0h
CALL read_ids ; probar 1 Mbps
MOV AL,0D7h ; indicar 2.88M en 2.88M
JC dm_fails ; no funciona
dm_slow_ok: JMP dm_result
detect_media ENDP
; ------------ Efectuar una lectura de ID's a velocidad AL (bits 6-7).
read_ids PROC
PUSH BX
PUSHF
CLI
MOV BYTE PTR DS:[40h],0FFh ; evitar detención motor
POPF
XSHR AL,6 ; colocar bits de velocidad
MOV DH,AL
CALL set_rate ; velocidad de transferencia DH
MOV DL,r_dl
CALL recalibrate ; recalibrar
JNC read_id_try
CALL recalibrate ; segundo intento
JC read_id_err
read_id_try: MOV CX,3 ; 3 intentos
read_id_retry: PUSH CX
MOV DH,DL ; en el cabezal 0 de la unidad
MOV DL,4Ah ; comando de leer ID's
MOV SI,DX
MOV DL,DH
MOV CH,2 ; comando de 2 bytes
AND BYTE PTR DS:[3Eh],7Fh ; esperar interrupción
CALL exec_cmd
JC read_id_fails ; fallo
MOV BX,42h
MOV CX,7
CALL get_results ; leer bytes de resultados
JC read_id_fails
CALL get_bios_err ; obtener código de error
POP CX
OR AH,AH
JZ read_id_ret ; ya no hay fallo
LOOP read_id_retry ; reintentar
JMP read_id_err ; mala suerte
read_id_fails: POP CX
read_id_err: STC
read_id_ret: POP BX
RET
read_ids ENDP
; ------------ Seleccionar la velocidad de transferencia adecuada.
select_rate PROC
PUSH SI
MOV SI,90h
XOR DH,DH
ADD SI,DX ; [SI] -> estado físico unidad
MOV DH,[SI] ; estado físico nueva unidad
MOV DL,DS:[8Bh] ; control del medio físico
AND DX,0C0C0h ; aislar bits de velocidad
CMP DL,DH ; ¿velocidad ya seleccionada?
JE selected_rate
AND BYTE PTR DS:[8Bh],3Fh ; no: borrar la anterior
OR DS:[8Bh],DH ; indicar la nueva
AND DH,0C0h
XROL DH,2
CALL set_rate ; nueva velocidad transferencia
selected_rate: POP SI
MOV DX,r_dx ; restaurar DX
RET
select_rate ENDP
; ------------ Establecer la velocidad de transferencia DH.
set_rate PROC
PUSH AX
MOV AL,DH
MOV DX,3F7h ; registro de control del disquete
OUT DX,AL ; seleccionar velocidad
POP AX
RET
set_rate ENDP
; ------------ Esperar evento durante CX 18.2-avos de segundo.
wait_event PROC
PUSH AX
test_55ms: MOV AL,DS:[6Ch]
test_int: TEST BYTE PTR [BX],80h
JNZ fin_w_event ; llegó la interrupción
w_timer: CMP AL,DS:[6Ch]
JE test_int
LOOP test_55ms
STC ; no llegó la interrupción
fin_w_event: POP AX
RET
wait_event ENDP
; ------------ Simular la lectura del registro 10h de la CMOS, para
; el tipo de las disqueteras.
peek_cmos PROC
MOV AL,CS:tipo_drvs ; nuestro tipo simulado
RET
peek_cmos ENDP
; ------------ Esperar exactamente CX milisegundos.
retardo PROC
PUSHF
XPUSH <AX, BX, CX, DX>
retarda_mas: CMP CX,54 ; como máximo 54 ms cada vez
JBE retarda_fin
PUSH CX
MOV AX,54
CALL rt_ax
POP CX
SUB CX,54
JMP retarda_mas
retarda_fin: MOV AX,CX
CALL rt_ax
XPOP <DX, CX, BX, AX>
POPF
RET
rt_ax: PUSH CX
MOV DX,1000 ; retardo de hasta 54 ms
MUL DX
MUL CS:tbase
MOV CX,54925
DIV CX ; AX = contador iteraciones
MOV CX,AX
EVEN ; forzar alineamiento
retarda: DEC CX
JMP SHORT $+2
JNZ retarda
POP CX
RET
retardo ENDP
retardo53 PROC
MOV CX,CS:tbase
MOV CL,CH
MOV CH,0
SHR CX,1
SHR CX,1
EVEN ; forzar alineamiento
retarda_res: DEC CX
JMP SHORT $+2
JNZ retarda_res ; pausa de 53 µs
RET
retardo53 ENDP
; ------------ Datos.
tipo_drvs DB 0 ; tipo de disqueteras (definido al instalar)
tbase DW ? ; cte de tiempo para bucles de retardo
; --- Tabla de saltos a las funciones
tab_jmp DW reset, get_status
DW read_wr_verify, read_wr_verify, read_wr_verify
DW format_track, get_drv_param, get_disk_type
DW detect_change, set_type_fmt, set_media_fmt
; --- Tabla de tamaños en sectores y cilindros
tab_disksize DW 9 + 39 * 256 ; 360K
DW 15 + 79 * 256 ; 1.2M
DW 9 + 79 * 256 ; 720K
DW 18 + 79 * 256 ; 1.44M
DW 36 + 79 * 256 ; 2.88M
; --- Tablas de parámetros de disco (sintaxis INT 1Eh)
tab_ptr_1e DW t360in360, t1200, t720, t1440, t2880
; Bytes de esta tabla, similar a la de INT 1Eh:
;
; 0) byte 1 para 'Specify' (step rate-head unload)
; 1) byte 2 para 'Specify' (head load-modo DMA)
; 2) tics de reloj hasta detención del motor
; 3) tamaño de sector (0-128, 1-256, 2-512, ...)
; 4) sectores por pista
; 5) GAP3 para lectura/escritura
; 6) longitud concreta de sector si tamaño=0
; 7) GAP3 para formateo
; 8) byte de relleno al formatear
; 9) tiempo de estabilización del cabezal en ms
; 10) tiempo aceleración motor, en 1/8 segundos
; 11) número de cilindros menos uno
; 12) velocidad de transferencia (en bits 6-7)
t360in360 DB 0DFh, 002h, 025h, 002h, 009h ; 360K en 360K
DB 02Ah, 0FFh, 050h, 0F6h, 00Fh
DB 008h, 027h, 080h
t1200 DB 0DFh, 002h, 025h, 002h, 00Fh ; 1.2M
DB 01Bh, 0FFh, 054h, 0F6h, 00Fh
DB 008h, 04Fh, 000h
t720 DB 0DFh, 002h, 025h, 002h, 009h ; 720K
DB 02Ah, 0FFh, 050h, 0F6h, 00Fh
DB 008h, 04Fh, 080h
t1440 DB 0BFh, 002h, 025h, 002h, 012h ; 1.44M
DB 01Bh, 0FFh, 06Ch, 0F6h, 00Fh
DB 008h, 04Fh, 000h
t360en1200 DB 0DFh, 002h, 025h, 002h, 009h ; 360K en 1.2M
DB 02Ah, 0FFh, 050h, 0F6h, 00Fh
DB 008h, 027h, 040h
t2880 DB 0AFh, 002h, 025h, 002h, 024h ; 2.88M
DB 01Bh, 0FFh, 050h, 0F6h, 00Fh
DB 008h, 04Fh, 0C0h
; --- Fin del área residente para INT 40h
fin_residente EQU $
bytes_resid EQU fin_residente-ini_residente
; ------------ Rutina de gestión de INT 13h (si se necesita). Se llama
; a la INT 40h de manera que esta última no devuelva
; nunca errores de frontera de DMA, para lo que emplea un
; buffer auxiliar de 512 bytes para transferir el sector
; que cruzaría la frontera. En la función de formateo, al
; acceder a la primera pista del disco se invoca primero
; la interrupción original para que el DOS (cargado antes
; que este programa) se entere del cambio de soporte.
ges_int13 PROC
STI
CMP DL,80h
JB floppy
JMP CS:ant_int13
floppy: CMP AH,2
JB floppy_bios
CMP AH,5
JE test_format
JB test_rwv
floppy_bios: INT 40h ; función sin problemas de DMA
RETF 2
ges_int13 ENDP
test_format PROC
XPUSH <DS, ES, BX>
XPUSHA
PUSH DX
OR DH,CH
POP DX
JNZ skip_aviso ; no es pista y cabezal 0
XPUSHA
MOV AL,1 ; formatear un sector (AH=5)
MOV CH,0
MOV DH,2 ; en cabezal 2 (incorrecto)
PUSHF
CALL CS:ant_int13 ; avisar al DOS del nuevo disco
XPOPA
skip_aviso: MOV DI,CS:pbuffer
MOV SI,BX
PUSH ES
POP DS
PUSH CS
POP ES
MOV CX,256
CLD
REP MOVSW ; datos de formateo al buffer
XPOPA ; auxiliar
MOV BX,CS:pbuffer
INT 40h ; formateo
XPOP <BX, ES, DS> ; restaurar registros iniciales
RETF 2
test_format ENDP
test_rwv PROC ; para Read/Write/Verify
MOV CS:funcion,AH
MOV CS:nsects,AL
XPUSH <SI, DI>
XPUSH <AX, DX>
MOV AX,ES
MOV DX,16
MUL DX
ADD AX,BX
NEG AX ; AX = bytes hasta frontera DMA
XSHR AX,9
MOV SI,AX ; sectores antes frontera
XPOP <DX, AX>
PUSH AX
MOV AH,0
MOV DI,AX
POP AX
CMP SI,DI
JBE trwv_no_sobra
MOV SI,DI
trwv_no_sobra: SUB DI,SI ; sectores+1 tras frontera
JZ trwv_1ok
PUSH CX
MOV CX,SI
MOV AL,CL ; AL sectores antes de frontera
POP CX
trwv_1ok: AND AL,AL
JZ trwv_1cruza ; primer sector cruza frontera
INT 40h
PUSHF
JNC trwv_cont ; sin fallo E/S
trwv_exit: JMP trwv_ret
trwv_cont: AND DI,DI
JZ trwv_exit ; se acabó
POPF
trwv_1cruza: CMP CS:funcion,3 ; ¿escritura?
JNE trwv_sectdma
XPUSHA
XPUSH <DS, ES>
XSHL SI,9 ; sectores transferidos * 512
ADD SI,BX
MOV DI,CS:pbuffer
PUSH ES
POP DS
PUSH CS
POP ES
MOV CX,256
CLD
REP MOVSW ; sector conflictivo a través
XPOP <ES, DS> ; de buffer auxiliar
XPOPA
trwv_sectdma: XPUSH <ES, BX, CX>
PUSH CS
POP ES
MOV BX,CS:pbuffer ; ES:BX buffer auxiliar
MOV AH,CS:funcion
MOV AL,1 ; un sector
ADD CX,SI ; nuevo sector inicial
INT 40h
XPOP <CX, BX, ES>
PUSHF
JC trwv_ret ; fallo E/S
CMP CS:funcion,2 ; ¿lectura?
JNE trwv_tras?
XPUSHA
XPUSH <DS, ES>
XSHL SI,9 ; sectores transferidos * 512
MOV DI,SI
ADD DI,BX
MOV SI,CS:pbuffer
PUSH CS
POP DS
MOV CX,256
CLD
REP MOVSW ; sector conflictivo a través
XPOP <ES, DS> ; de buffer auxiliar
XPOPA
trwv_tras?: MOV AL,CS:nsects ; sectores transferidos
DEC DI
JZ trwv_ret ; no queda nada tras frontera
POPF
XPUSH <BX, CX>
INC SI
ADD CX,SI ; nuevo sector inicial
XSHL SI,9 ; sectores transferidos * 512
ADD BX,SI
MOV AX,DI ; sectores restantes
MOV AH,CS:funcion
INT 40h
XPOP <CX, BX>
MOV AL,CS:nsects ; número sectores transferidos
PUSHF
trwv_ret: POPF
XPOP <DI, SI>
RETF 2
test_rwv ENDP
funcion DB ?
nsects DB ?
pbuffer DW buffer_io
EVEN
buffer_io EQU $
; *****************************
; * *
; * I N S T A L A C I O N *
; * *
; *****************************
main PROC
ADD SP,2 ; quitar dirección de retorno
XPUSH <AX, BX, CX, DX, SI, DI, BP, DS, ES>
PUSH CS
POP DS
MOV WORD PTR interrupcion,531Eh ; opcode PUSH DS,BX
MOV BYTE PTR interrupcion+2,0BBh ; opcode MOV BX,??
PUSH CS
POP ES
CALL inic_general ; inicializar ciertas variables
CALL analiza_equipo
CALL lee_params ; parámetros de tipo unidades
CALL set_params ; actualizar tipo de unidades
CALL valida_drives ; asegurar que hay unidades
TEST error,0FFFFh
JNZ exit_ins
CALL hay2m?
JC no_2m
OR error,ERR_HAY2M ; 2M ó 2MX residente
JMP exit_ins
no_2m: TEST accion,I40 ; ¿soporta INT 40h el sistema?
JNZ i40_ok ; en efecto
CALL set_i13 ; añadir soporte vía INT 13h
i40_ok: CALL cte_tiempos
MOV tbase,AX
CALL init_vars
CALL mx_get_handle ; obtener entrada Multiplex
JNC handle_ok
OR error,MX64FULL ; no quedan entradas
JMP exit_ins
handle_ok: MOV multiplex_id,AH ; entrada multiplex para 2M
CALL preservar_ints ; tomar nota de vectores
CALL activar_ints ; interceptar vectores
CALL set_dev_params ; establecer tipo unidades DOS
exit_ins: CALL info
MOV BX,pcab_pet_segm
MOV ES,BX
MOV BX,pcab_pet_desp
MOV WORD PTR ES:[BX+3],100h ; indicar retorno correcto
MOV AX,longitud_total
MOV CL,4
SHL AX,CL
TEST error,0FFFFh
JZ exit_ok
MOV WORD PTR ES:[BX+14],0 ; OFFSET 0: no quedará
MOV WORD PTR ES:[BX+16],CS ; instalado en memoria
JMP exit_interr
exit_ok: MOV WORD PTR ES:[BX+14],AX ; OFFSET al último byte residente
MOV WORD PTR ES:[BX+16],CS
exit_interr: XPOP <ES, DS, BP, DI, SI, DX, CX, BX, AX>
RETF
main ENDP
; ------------ Leer los parámetros en la línea del CONFIG (ES:BX).
lee_params PROC
PUSH ES
MOV BX,pcab_pet_segm
MOV ES,BX
MOV BX,pcab_pet_desp
LES BX,ES:[BX+12h] ; apuntar a los parámetros
CALL salta_nombre ; buscar inicio parámetros
mas_param: CALL busca_param ; saltar delimitadores
JC fin_params ; no hay parámetros
otro_drive: CMP AX,':a'
JE unidad_ok
CMP AX,':b' ; admitidas A: y B:
JE unidad_ok
param_error: OR error,ERR_SYNTAX ; error de sintaxis
POP ES
RET
unidad_ok: MOV CL,ES:[BX+2]
SUB CL,'0' ; tipo de la unidad
SUB AL,'a'
MOV AH,0
LEA DI,tipos_drv
ADD DI,AX
CMP CL,5 ; ¿tipo entre 0 y 5?
JA param_error
MOV [DI],CL ; definir tipo
ADD BX,3
JMP mas_param ; próximo parámetro
fin_params: POP ES
RET
lee_params ENDP
salta_nombre PROC ; saltar nombre del driver en
MOV AL,ES:[BX] ; línea de órdenes del CONFIG
INC BX
CMP AL,' '
JE fin_nombre
CMP AL,9
JE fin_nombre
CMP AL,0Dh
JE fin_nombre
CMP AL,0Ah
JE fin_nombre
AND AL,AL
JZ fin_nombre
JMP salta_nombre
fin_nombre: RET
salta_nombre ENDP
busca_param PROC ; saltar delimitadores
DEC BX
p_delimit: INC BX
MOV AX,ES:[BX]
CMP AL,' '
JE p_delimit ; espacio en blanco
CMP AL,9
JE p_delimit ; tabulador
CMP AL,13
JE p_final ; CR ó LF indican el final
CMP AL,10
JE p_final
OR AX," " ; poner en minúsculas
CLC
RET
p_final: STC ; se acabaron los parámetros
RET
busca_param ENDP
; ------------ Establecer tipo disqueteras (según BIOS o parámetros).
set_params PROC
PUSH ES
MOV AL,tipos_drv
CMP AL,-1
JNE ta_calc ; A: definida por el usuario
MOV AH,8
MOV DL,0
INT 13h ; consultar tipo a la BIOS
MOV AL,BL
JNC ta_val
JMP set_type_exit ; unidad no existente
ta_val: CMP DL,1
JB set_type_exit
ta_calc: CMP AL,4
JBE ta_set
MOV AL,5 ; 2.88M representado por 5
ta_set: AND tipo_drvs,0Fh
MOV CL,4
SHL AL,CL
OR tipo_drvs,AL ; tipo A: en nibble alto
MOV AL,tipos_drv+1
CMP AL,-1 ; B: definida por el usuario
JNE tb_calc
MOV AH,8
MOV DL,1
INT 13h ; consultar tipo a la BIOS
MOV AL,BL
JC set_type_exit
CMP DL,2
JB set_type_exit ; unidad no existente
tb_calc: CMP AL,4
JBE tb_set
MOV AL,5 ; 2.88M representado por 5
tb_set: AND tipo_drvs,0F0h
OR tipo_drvs,AL ; tipo B: en nibble bajo
set_type_exit: POP ES
RET
set_params ENDP
; ------------ Asegurar que se conoce el tipo de las unidades.
valida_drives PROC
MOV AL,tipo_drvs
AND AL,0F0h
JNZ drvs_ok
OR error,ERR_MALDRV
drvs_ok: RET
valida_drives ENDP
; ------------ Código ejecutado desde la línea de comandos.
inicio PROC FAR
MOV AX,_PRINCIPAL
MOV DS,AX
CALL param_i?
MOV AX,DS
MOV ES,AX
CALL residente?
JC dos_info
CALL cte_tiempos
MOV ES,tsr_seg
MOV ES:tbase,AX
LEA DX,info_adj_txt
CALL print
CMP param_hlp,ON
JE dos_info
JMP dos_exit
dos_info: LEA DX,info_txt
CALL print
dos_exit: MOV AX,4C00h
INT 21h ; final normal
inicio ENDP
; ----- Buscar posible parámetro /I ó /?
param_i? PROC
MOV DI,80h
MOV CL,ES:[DI]
MOV CH,0
INC CX
busca_mas: MOV DL,OFF
JCXZ ret_bparam
busca_barra: INC DI
CMP BYTE PTR ES:[DI],'/'
LOOPNE busca_barra
JNE ret_bparam
MOV AL,ES:[DI+1]
OR AL,32
MOV DL,ON
CMP AL,'i'
JE pmt_i
CMP AL,'?'
JE pmt_hlp
CMP AL,'h'
JE pmt_hlp
JMP busca_mas
pmt_i: MOV param_i,DL
JMP busca_mas
pmt_hlp: MOV param_hlp,DL
JMP busca_mas
ret_bparam: RET
param_i? ENDP
; ------------ Inicializar ciertas variables.
inic_general PROC
MOV AX,(bytes_resid+15)/16
MOV longitud_total,AX ; memoria necesaria
MOV segmento_real,CS ; anotar segmento del bloque
MOV offset_real,0 ; ídem con el offset
RET
inic_general ENDP
; ------------ Comprobar que la configuración es la adecuada. Para
; saber si la INT 13h de este ordenador acaba llamando a
; la INT 40h, se desvía la INT 40h y se provoca un inocuo
; reset de disquetes vía INT 13h para comprobar si pasa
; por la INT 40h.
analiza_equipo PROC
PUSH ES
CALL testAT
MOV AX,ERR_TIPOPC
JNC cod_err_ok ; no es PC/XT
CALL test_i40
XOR AX,AX
cod_err_ok: OR error,AX
POP ES
RET
analiza_equipo ENDP
; --- Comprobar si la INT 40h está en uso
test_i40: XPUSH <DS, ES> ; *
MOV AX,3540h
INT 21h
XPUSH <ES, BX> ; vector de INT 40h original
LEA DX,i40_aux
MOV AX,2540h
INT 21h ; establecer nueva INT 40h
XOR AX,AX
MOV DL,0
INT 13h ; reset de disco
XPOP <DX, DS>
MOV AX,2540h
INT 21h ; restaurar INT 40h original
XPOP <ES, DS> ; *
RET
i40_aux PROC
OR CS:accion,I40 ; sí utilizada INT 40h
IRET ; desde la INT 13h
i40_aux ENDP
; ----- Detectar 286 ó superior.
testAT PROC
PUSHF
POP AX
OR AH,70h ; intentar activar bit 12, 13 ó 14
PUSH AX ; del registro de estado
POPF
PUSHF
POP AX
AND AH,0F0h
CMP AH,0F0h
JE testedAT
STC
testedAT: CMC ; CF = 0 en AT y 1 en PC/XT
RET
testAT ENDP
; ------------ Desviar también INT 13h ya que en esta máquina el
; gestor de INT 13h no invoca la INT 40h.
set_i13 PROC
INC offsets_ints ; usado un vector más
INC BYTE PTR tabla_vectores-1
MOV AX,CS
MOV CX,16
MUL CX
ADD AX,pbuffer
ADC DX,0 ; DX:AX = dirección 20 bits
MOV CX,DX
PUSH AX
ADD AX,511 ; buffer para el mayor sector
ADC DX,0
POP AX
CMP DX,CX
JE dma_ok
NEG AX
ADD pbuffer,AX ; saltar hasta próxima frontera
OR accion,BUFFERPLUS
dma_ok: MOV AX,pbuffer
ADD AX,512
SUB AX,OFFSET ges_int13
ADD AX,15
MOV CL,4
SHR AX,CL
ADD longitud_total,AX ; es necesaria más memoria
RET
set_i13 ENDP
; ------------ Establecer el tipo de las unidades a nivel DOS.
set_dev_params PROC
MOV AH,30h
INT 21h
XCHG AH,AL
CMP AX,314h
JB dev_set ; DOS < 3.2 -> no soportado
MOV BX,1
set_otro_dev: PUSH BX
MOV AH,8
MOV DL,BL
DEC DL
PUSH BX
PUSH ES
INT 13h ; obtener tipo de la unidad
POP ES
MOV BH,0
SHL BX,1
ADD BX,OFFSET ptr_dev_info
MOV DX,[BX] ; DS:DX -> tabla de información
POP BX
AND DX,DX
JZ device_set
MOV AX,440Dh ; IOCTL
MOV CX,0840h
INT 21h ; establecer tipo de soporte
device_set: POP BX
INC BX
CMP BX,2
JBE set_otro_dev
dev_set: RET
set_dev_params ENDP
; ------------ Preservar vectores de interrupción previos.
preservar_INTs PROC
XPUSH <ES, DI>
LEA DI,tabla_vectores
MOV CL,[DI-1]
MOV CH,0 ; CX vectores interceptados
otro_vector: XPUSH <CX, DI>
MOV AH,35h
MOV AL,[DI]
INT 21h ; obtener vector de INT xx
XPOP <DI, CX>
MOV [DI+1],BX ; anotar donde apunta
MOV [DI+3],ES
ADD DI,5
LOOP otro_vector ; repetir con los restantes
XPOP <DI, ES>
RET
preservar_INTs ENDP
; ------------ desviar vectores de interrupción a las nuevas rutinas.
activar_INTs PROC
LEA SI,offsets_ints
MOV CX,CS:[SI] ; CX vectores a desviar
ADD SI,2
desvia_otro: MOV AL,CS:[SI] ; número del vector en curso
MOV DX,CS:[SI+1] ; obtener offset
MOV AH,25h
INT 21h ; desviar INT xx a DS:DX
ADD SI,3
LOOP desvia_otro
RET
activar_INTs ENDP
; ------------ Buscar entrada no usada en la interrupción Multiplex.
; A la salida, CF=1 si no hay hueco (ya hay 64 programas
; residentes instalados con esta técnica). Si CF=0, se
; devuelve en AH un valor de entrada libre en la INT 2Fh.
mx_get_handle PROC
MOV AH,0C0h
mx_busca_hndl: PUSH AX
MOV AL,0
INT 2Fh
CMP AL,0FFh
POP AX
JNE mx_si_hueco
INC AH
JNZ mx_busca_hndl
STC
RET
mx_si_hueco: CLC
RET
mx_get_handle ENDP
; ------------ Devolver CF=0 si 2M o 2MX están instalados o se ha
; cargado el código 2M en modo SuperBOOT.
hay2m? PROC
PUSH ES
LEA SI,id_2m ; identificación del programa
MOV CX,id_2m_tam
MOV AX,1492h
MOV ES,AX
MOV DI,1992h ; ES:DI protocolo de búsqueda
CALL mx_find_tsr ; buscar si está en memoria
JNC hay2m?_ret
LEA SI,id_2mx ; identificación del programa
MOV CX,id_2mx_tam
CALL mx_find_tsr
JNC hay2m?_ret
INT 12h ; tamaño memoria convencional
CMP AX,640
JBE base_sc_ok
MOV AX,640 ; alguien la ha manipulado
base_sc_ok: SUB AX,5
MOV BX,64
MUL BX ; AX = segmento de SuperBOOT
MOV CX,6
scan_boot: PUSH CX
MOV ES,AX
MOV DI,6
LEA SI,id_boot
MOV CX,id_boot_tam
CLD
REP CMPSB
POP CX
JE hay2m?_ret ; CF = 0 -> 2M SuperBOOT
SUB AX,1000h
LOOP scan_boot ; buscar 64K más abajo
STC
hay2m?_ret: POP ES
RET
hay2m? ENDP
; ------------ Comprobar si el programa ya reside en memoria. A la
; salida, CF=0 si programa ya reside, con «tsr_seg» y
; «tsr_off» inicializadas apuntando a la cadena de
; identificación de la copia residente. Si CF=1, el
; programa no reside aún (AX=0) o reside pero en otra
; versión distinta (AX=1).
residente? PROC
XPUSH <CX, SI, DI, ES, AX>
LEA DI,autor_nom_ver ; identificación del programa
MOV SI,DI
MOV AL,0
MOV CL,255
CLD
REPNE SCASB
SUB DI,SI
MOV CX,DI ; tamaño autor+programa+versión
MOV AX,1492h
MOV ES,AX
MOV DI,1992h ; ES:DI protocolo de búsqueda
CALL mx_find_tsr ; buscar si está en memoria
MOV tsr_off,DI ; anotar la dirección programa
MOV tsr_seg,ES ; por si estaba instalado
POP AX
JNC resid_ok ; CF=0 -> programa ya residente
POP ES
PUSH ES
LEA DI,autor_nom_ver
MOV SI,DI
MOV AL,':'
MOV CL,255
REPNE SCASB
REPNE SCASB
SUB DI,SI
MOV CX,DI ; tamaño autor+programa
MOV AX,1492h
MOV ES,AX
MOV DI,1992h ; ES:DI protocolo de búsqueda
CALL mx_find_tsr ; buscar si está en memoria
MOV tsr_off,DI ; anotar dirección del programa
MOV tsr_seg,ES ; por si instalada otra versión
MOV AX,0
JC resid_ok ; CF=1, AX=0 -> no residente
MOV AX,1
STC ; CF=1, AX=1 -> sí: otra vers.
resid_ok: XPOP <ES, DI, SI, CX>
RET
residente? ENDP
; ------------ Buscar un TSR por la interrupción Multiplex. A la
; entrada, DS:SI cadena de identificación del programa
; (CX bytes) y ES:DI protocolo de búsqueda (normalmente
; 1492h:1992h). A la salida, si el TSR ya está instalado,
; CF=0 y ES:DI apunta a la cadena de identificación del
; mismo. Si no, CF=1 y ningún registro alterado.
mx_find_tsr PROC
MOV AH,0C0h
mx_rep_find: XPUSH <AX, CX, SI, DS, ES, DI>
MOV AL,0
PUSH CX
INT 2Fh
POP CX
CMP AL,0FFh
JNE mx_skip_hndl ; no hay TSR ahí
CLD
PUSH DI
REP CMPSB ; comparar identificación
POP DI
JE mx_tsr_found ; programa buscado hallado
mx_skip_hndl: XPOP <DI, ES, DS, SI, CX, AX>
INC AH
JNZ mx_rep_find
STC
RET
mx_tsr_found: ADD SP,4 ; «sacar» ES y DI de la pila
XPOP <DS, SI, CX, AX>
CLC
RET
mx_find_tsr ENDP
; ------------ Informar al usuario.
info PROC
TEST error,0FFFFh
JZ info_mas
LEA DX,no_inst_txt
CALL print
LEA DX,mal_cpu_txt
TEST error,ERR_TIPOPC
JNZ print_err
LEA DX,hay2m_txt
TEST error,ERR_HAY2M
JNZ print_err
LEA DX,null_drv_txt
TEST error,ERR_MALDRV
JNZ print_err
LEA DX,err_syntax_txt
TEST error,ERR_SYNTAX
JNZ print_err
LEA DX,err_mx64full
TEST error,MX64FULL
JZ fin_info
print_err: CALL print
RET
info_mas: LEA DX,instalado_txt
CALL print
CALL info_drives
TEST accion,BUFFERPLUS
JZ fin_info
LEA DX,dma_cross_txt
CALL print
fin_info: RET
info ENDP
; --- Informar de las unidades controladas.
info_drives PROC
MOV AH,8
MOV DL,0
INT 13h
JC info_null ; no hay información sobre A:
AND BL,BL
JZ info_null
CMP DL,1
JB info_null
PUSH DX
MOV BH,0
DEC BX
SHL BX,1
LEA DX,a_txt ; "A:"
CALL print
MOV DX,[BX+OFFSET ptr_txt_tipos] ; su tipo
CALL print
POP DX
CMP DL,2
JB info_exit ; no hay información sobre B:
MOV AH,8
MOV DL,1
INT 13h
JC info_exit
AND BL,BL
JZ info_exit
MOV BH,0
DEC BX
SHL BX,1
LEA DX,b_txt ; "B:"
CALL print
MOV DX,[BX+OFFSET ptr_txt_tipos] ; su tipo
CALL print
info_exit: LEA DX,i40_txt
TEST accion,I40
JNZ imodo_ok
LEA DX,i13_txt
imodo_ok: CALL print ; modo de instalación
RET
info_null: LEA DX,null_drv_txt ; sin indicar tipo de unidades
CALL print
RET
info_drives ENDP
; ------------ Calcular la constante de retardo básica para perder
; exactamente 54,925 ms. Con una regla de 3 se podrá
; después aplicar para hacer retardos de milisegundos.
cte_tiempos PROC
XPUSH <DS, ES, BX, CX, DX>
MOV AX,3508h
INT 21h
XPUSH <ES, BX> ; preservar vector de INT 8
PUSH DS
MOV AX,40h
MOV DS,AX
MOV AL,DS:[6Ch]
espera_i8: CMP AL,DS:[6Ch]
JE espera_i8 ; esperar INT 8 ... para que no
POP DS
LEA DX,i8_crono ; venga otra en un buen rato...
MOV AX,2508h
INT 21h ; nueva rutina de INT 8
IN AL,21h
PUSH AX ; preservar estado de IRQ's
MOV AL,11111110b
OUT 21h,AL ; permitir sólo IRQ0
MOV AH,0 ; fase
MOV CX,0 ; contador
MOV BX,CX ; seguiría a 0 si fallara
EVEN ; forzar alineamiento
cuenta_iter: DEC CX ; <─┐ bucle básico de retardo
JMP SHORT $+2 ; │
JNZ cuenta_iter ; <─┘ lo interrumpirá INT 8
POP AX ; anterior estado de IRQ's
OUT 21h,AL
XPOP <DX, DS>
PUSH BX ; valor real contado
MOV AX,2508h ; restaurar vector de INT 8
INT 21h
POP AX ; (65536-AX) vueltas en 54,9 ms
NEG AX ; constante de retardo básica
XPOP <DX, CX, BX, ES, DS>
RET
i8_crono: INC AH ; nueva INT 8 que interrumpe
CMP AH,1 ; el bucle de retardo
JE fase1
CMP AH,2
JE fase2
i8_exit: MOV AL,20h
OUT 20h,AL
IRET
fase1: MOV CX,0 ; sincronizar con el reloj
JMP i8_exit
fase2: MOV BX,CX ; anotar constante de retardo
MOV CX,1 ; forzar fin del bucle
JMP i8_exit
cte_tiempos ENDP
; ------------ Inicializar variables en el área de datos de la BIOS.
init_vars PROC
PUSH DS
MOV AX,40h
MOV DS,AX
AND BYTE PTR DS:[3Eh],01110000b
MOV BYTE PTR DS:[8Bh],00000000b
MOV DX,3F7h
MOV AL,0
OUT DX,AL
MOV BYTE PTR DS:[8Fh],01110111b
MOV BYTE PTR DS:[90h],0
MOV BYTE PTR DS:[91h],0
POP DS
RET
init_vars ENDP
; ------------ Inicializar variable idioma_sp según idioma del país.
habla_hispana? PROC
XPUSH <AX, BX, CX, DX, BP>
MOV AH,30h
INT 21h
XCHG AH,AL ; AX = versión del DOS
MOV BP,AX
MOV idioma_sp,OFF ; supuesto de habla no hispana
CMP BP,200h
JB habla_ok
LEA DX,buffer_aux
MOV AX,3800h
INT 21h ; obtener información del pais
CMP BP,20Bh
JE habla_ax ; DOS 2.11: AX cód. telefónico
CMP BP,300h
JB habla_ok ; 2.x excepto 2.11: mala suerte
MOV AX,BX
habla_ax: LEA BX,paises_sp-2
MOV CX,numpaises_sp
habla_sp?: ADD BX,2
CMP AX,[BX]
JE habla_hispana
LOOP habla_sp?
habla_ok: MOV AL,param_i
XOR idioma_sp,AL ; considerar parámetro /I
XPOP <BP, DX, CX, BX, AX>
RET
habla_hispana: MOV idioma_sp,ON ; país de habla hispana
MOV AL,param_i
XOR idioma_sp,AL ; considerar parámetro /I
XPOP <BP, DX, CX, BX, AX>
RET
habla_hispana? ENDP
; ------------ Imprimir cadena en DS:DX delimitada por un 0 ó un 255.
; Si hay que imprimir en inglés se toma la cadena que va
; después si ésta acaba en 255 (si acaba en 0, no hay
; distinción entre mensaje castellano e inglés).
print PROC
XPUSH <AX, BX, CX, DX>
pr_decidir: CMP idioma_sp,OFF
JE usar_uk
CMP idioma_sp,ON
JE usar_sp
PUSH DX
CALL habla_hispana? ; determinar lengua
POP DX
JMP pr_decidir
usar_uk: MOV BX,DX
DEC BX
usar_uk?: INC BX
CMP BYTE PTR [BX],0
JE usar_sp ; acaba en 0: no traducir
CMP BYTE PTR [BX],255
JNE usar_uk?
LEA DX,[BX+1] ; acaba en 255: traducir
usar_sp: MOV BX,DX
DEC BX
print_cad: INC BX
CMP BYTE PTR [BX],0
JE prlong_ok
CMP BYTE PTR [BX],255
JNE print_cad ; calcular longitud
prlong_ok: MOV CX,BX
SUB CX,DX
MOV AH,40h
MOV BX,1
INT 21h
XPOP <DX, CX, BX, AX>
RET
print ENDP
; ************ Datos no residentes para la instalación
ON EQU 1 ; constantes booleanas
OFF EQU 0
param_i DB OFF ; a ON si indicado parámetro /I
param_hlp DB OFF ; a ON si se solicita ayuda
tsr_dir LABEL DWORD ; dirección de la copia residente
tsr_off DW 0
tsr_seg DW 0
tipos_drv DB -1 ; tipo de A:
DB -1 ; y de B:
id_2m DB "CiriSOFT:2M:"
id_2m_tam EQU $-OFFSET id_2m
id_2mx DB "CiriSOFT:2MX:"
id_2mx_tam EQU $-OFFSET id_2mx
id_boot DB "2M-STV"
id_boot_tam EQU $-OFFSET id_boot
ERR_TIPOPC EQU 1 ; códigos de error
ERR_HAY2M EQU 2
ERR_MALDRV EQU 4
ERR_SYNTAX EQU 8
MX64FULL EQU 16
I40 EQU 1 ; códigos de acción
BUFFERPLUS EQU 2
offsets_ints DW 3 ; número de vectores interceptados
DB 15h ; tabla de offsets de los vectores
DW ges_int15 ; de interrupción interceptados
DB 2Fh
DW ges_int2F
DB 40h
DW ges_int40
DB 13h ; INT 13h podría usarse
DW ges_int13
ptr_dev_info DW 0, i360, i1200, i720, i1440, i2880
i360 DB 4, 0 ; sectores iguales / tipo 360K
DW 0, 40 ; no detecta cambio / nº pistas
DB 1 ; tipo de soporte
DW 512 ; BPB: bytes por sector
DB 2 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 2 ; BPB: número de FATs
DW 112 ; BPB: entradas en el raíz
DW 720 ; BPB: nº total de sectores
DB 0FDh ; BPB: descriptor de medio
DW 2 ; BPB: sectores por FAT
DW 9, 2 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
i1200 DB 4, 1 ; sectores iguales / tipo 1.2M
DW 2, 80 ; detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 512 ; BPB: bytes por sector
DB 1 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 2 ; BPB: número de FATs
DW 224 ; BPB: entradas en el raíz
DW 2400 ; BPB: nº total de sectores
DB 0F9h ; BPB: descriptor de medio
DW 7 ; BPB: sectores por FAT
DW 15, 2 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
i720 DB 4, 2 ; sectores iguales / tipo 720K
DW 0, 80 ; no detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 512 ; BPB: bytes por sector
DB 2 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 2 ; BPB: número de FATs
DW 112 ; BPB: entradas en el raíz
DW 1440 ; BPB: nº total de sectores
DB 0F9h ; BPB: descriptor de medio
DW 3 ; BPB: sectores por FAT
DW 9, 2 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
i1440 DB 4, 7 ; sectores iguales / tipo 1.44M
DW 2, 80 ; detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 512 ; BPB: bytes por sector
DB 1 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 2 ; BPB: número de FATs
DW 224 ; BPB: entradas en el raíz
DW 2880 ; BPB: nº total de sectores
DB 0F0h ; BPB: descriptor de medio
DW 9 ; BPB: sectores por FAT
DW 18, 2 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
i2880 DB 4, 9 ; sectores iguales / tipo 2.88M
DW 2, 80 ; detecta cambio / nº pistas
DB 0 ; tipo de soporte
DW 512 ; BPB: bytes por sector
DB 2 ; BPB: sectores por cluster
DW 1 ; BPB: sectores reservados
DB 2 ; BPB: número de FATs
DW 224 ; BPB: entradas en el raíz
DW 5760 ; BPB: nº total de sectores
DB 0F0h ; BPB: descriptor de medio
DW 9 ; BPB: sectores por FAT
DW 36, 2 ; BPB: sectores pista / cabezas
DB 14 DUP (0) ; BPB: restantes campos
accion DW 0
error DW 0
idioma_sp DB 5Ah ; ni en ON ni en OFF al principio
; --- Código telefónico de países de
; habla hispana (mucha o poca).
paises_sp DW 54 ; Argentina
DW 591 ; Bolivia
DW 57 ; Colombia
DW 506 ; Costa Rica
DW 56 ; Chile
DW 593 ; Ecuador
DW 503 ; El Salvador
DW 34 ; España
DW 63 ; Filipinas
DW 502 ; Guatemala
DW 504 ; Honduras
DW 212 ; Marruecos
DW 52 ; México
DW 505 ; Nicaragua
DW 507 ; Panamá
DW 595 ; Paraguay
DW 51 ; Perú
DW 80 ; Puerto Rico
DW 508 ; República Dominicana
DW 598 ; Uruguay
DW 58 ; Venezuela
DW 3 ; genérico latinoamérica
numpaises_sp EQU ($-OFFSET paises_sp)/2
; ------------ Texto.
info_adj_txt DB 13,10,"2M-XBIOS 1.2 ya instalado, base de tiempos ajustada.",13,10,255
DB 13,10,"2M-XBIOS 1.2 already installed, delay constant adjusted.",13,10,255
instalado_txt DB 13,10,"2M-XBIOS 1.2 instalado en ",255
DB 13,10,"2M-XBIOS 1.2 installed on ",0
a_txt DB "A:",0
b_txt DB " y B:",255," and B:",0
ptr_txt_tipos DW d360, d1200, d720, d1440, d2880
d360 DB "360K",0
d1200 DB "1.2M",0
d720 DB "720K",0
d1440 DB "1.44M",0
d2880 DB "2.88M",0
i40_txt DB " [INT 40h]",13,10,0
i13_txt DB " [INT 13h]",13,10,0
no_inst_txt DB 13,10,"2M-XBIOS 1.2 *NO* instalado.",13,10,255
DB 13,10,"2M-XBIOS 1.2 *NOT* installed.",13,10,0
mal_cpu_txt DB " + Error: necesario equipo PC/XT. Utilice 2M-ABIOS en este equipo.",13,10,255
DB " + Error: needs a PC/XT system. Try 2M-ABIOS on this system.",13,10,0
hay2m_txt DB " + Error: 2M-XBIOS debe instalarse *ANTES* de 2MX (y nunca en SuperBOOT).",13,10,255
DB " + Error: 2M-XBIOS must be installed *BEFORE* 2MX (and never in SuperBOOT).",13,10,0
null_drv_txt DB " + Utilice los parámetros para indicar expresamente el tipo de las unidades.",13,10,255
DB " + Please use the switches to set the correct diskette drives type.",13,10,0
err_syntax_txt DB " + Error de sintaxis: ejecútelo desde el símbolo DOS para obtener ayuda.",13,10,255
DB " + Syntax error: execute from DOS command line to obtain help.",13,10,0
err_mx64full DB " + Error: Ya hay 64 programas residentes con la misma técnica.",13,10,7,255
DB " + Error: There are already 64 TSR's with the same technique.",13,10,7,0
dma_cross_txt DB " - Nota: El buffer de E/S cruzaba una frontera de DMA y fue ampliado.",13,10
DB " Cambie la ubicación en memoria si desea ahorrar unos bytes.",13,10,255
DB " - Note: I/O buffer has been extended because it crosses a DMA boundary.",13,10
DB " Modify the memory location of 2M-XBIOS to save a little memory.",13,10,0
info_txt LABEL BYTE
DB 13,10
DB " 2M-XBIOS 1.2 - (c) Mayo 1994 Ciriaco García de Celis.",13,10
DB " C/Renedo, 2, 4-C; 47005 Valladolid (España) - ciri@gui.uva.es - 2:341/21.8",13,10,10
DB " Sintaxis: DEVICE=2M-XBIOS.EXE [A:tipo [B:tipo]]",13,10,10
DB " La mayoría de PC/XT tiene una BIOS antigua sin soporte de alta densidad",13,10
DB " aunque admiten una controladora de AT de alta densidad. Para trabajar con",13,10
DB " unidades de alta densidad necesitan 2M-XBIOS. Además, 2MX suele requerir",13,10
DB " que esté instalado 2M-XBIOS, que debería ser cargado antes que cualquier",13,10
DB " otro software de disco. Este programa es sólo para máquinas PC/XT.",13,10,10
DB " 2M-XBIOS actualiza el soporte de disco flexible a la última tecnología",13,10
DB " de las BIOS AMI de 1993. Si con 2M-XBIOS instalado 2MX no opera de manera",13,10
DB " totalmente correcta y en su máquina no está instalado algún otro software",13,10
DB " de disco incompatible con 2MX entonces su ordenador no es 100% compatible",13,10
DB " hardware con el estándar; esto es particularmente cierto si con 2M-XBIOS",13,10
DB " instalado no se reconocen siquiera los discos estándar del DOS.",13,10,10
DB " Este programa ocupa 3.4-4.2 Kb de RAM, y contiene una emulación al 100%",13,10
DB " del eficaz código de control de disco de las BIOS AMI, relevando así por",13,10
DB " completo de esta tarea a la BIOS del sistema. Generalmente será necesario",13,10
DB " indicar el tipo (0:no hay, 1:360K, 2:1.2M, 3:720K, 4:1.44M, 5:2.88M). AMI",13,10
DB " es marca registrada de American Megatrends Inc.",13,10
DB 255
DB 13,10,10
DB " 2M-XBIOS 1.2 - (c) Mayo 1994 Ciriaco García de Celis.",13,10
DB " C/Renedo, 2, 4-C; 47005 Valladolid (Spain) - ciri@gui.uva.es - 2:341/21.8",13,10,10
DB " Syntax: DEVICE=2M-XBIOS.EXE [A:type [B:type]]",13,10,10
DB " Most PC/XT systems have an old BIOS with no high density support, but",13,10
DB " they can be equiped with an AT high density disk controller. To work with",13,10
DB " high density drives they need 2M-XBIOS. Also, 2MX usually requires the",13,10
DB " previous installation of 2M-XBIOS: you must install it before any other",13,10
DB " disk TSR software. This program is only for use on PC/XT systems.",13,10,10
DB " 2M-XBIOS upgrades floppy-disk support to last AMI BIOS 1993 technology.",13,10
DB " If 2M-XBIOS is installed, and 2MX continues not working full correctly on",13,10
DB " your computer, and is not installed in the system any other disk software",13,10
DB " incompatible with 2MX, this probably means that your computer is not 100%",13,10
DB " hardware compatible with the standard XT; this is specially true if only",13,10
DB " 2M-XBIOS is installed and DOS standard diskettes don't work.",13,10,10
DB " This program takes 3.4-4.2 Kb of RAM, and provides a full emulation of",13,10
DB " the effective disk control management of AMI BIOS, absolutely overriding",13,10
DB " your native BIOS in this job. Usually, you will need to select the drive",13,10
DB " type (0:not present, 1:360K, 2:1.2M, 3:720K, 4:1.44M, 5:2.88M). AMI is a",13,10
DB " registered trademark of American Megatrends Inc.",13,10
DB 0
buffer_aux DB 64 DUP (0) ; buffer para alguna función del DOS
_PRINCIPAL ENDS
_PILA SEGMENT STACK 'STACK'
DB 1024 DUP (?) ; 1 Kb de pila es suficiente
_PILA ENDS
END inicio